Store sym links as the referenced file by default

Author: kiendang

os/src/ZipOps.scala

@@ -3,8 +3,13 @@ package os
 import os.{shaded_org_apache_tools_zip => apache}
 
 import java.net.URI
-import java.nio.file.{FileSystem, FileSystems, Files}
-import java.nio.file.attribute.{BasicFileAttributeView, FileTime, PosixFilePermissions}
+import java.nio.file.{FileSystem, FileSystems, Files, LinkOption}
+import java.nio.file.attribute.{
+  BasicFileAttributes,
+  BasicFileAttributeView,
+  FileTime,
+  PosixFilePermissions
+}
 import java.util.zip.{ZipEntry, ZipFile, ZipInputStream, ZipOutputStream}
 import scala.collection.JavaConverters._
 import scala.util.matching.Regex
@@ -45,7 +50,8 @@ object zip {
       includePatterns: Seq[Regex] = List(),
       preserveMtimes: Boolean = false,
       deletePatterns: Seq[Regex] = List(),
-      compressionLevel: Int = java.util.zip.Deflater.DEFAULT_COMPRESSION
+      compressionLevel: Int = java.util.zip.Deflater.DEFAULT_COMPRESSION,
+      preserveLinks: Boolean = false
   ): os.Path = {
     checker.value.onWrite(dest)
     // check read preemptively in case "dest" is created
@@ -84,6 +90,7 @@ object zip {
           includePatterns,
           preserveMtimes,
           compressionLevel,
+          preserveLinks,
           f
         )
       finally f.close()
@@ -115,6 +122,7 @@ object zip {
       includePatterns: Seq[Regex],
       preserveMtimes: Boolean,
       compressionLevel: Int,
+      preserveLinks: Boolean,
       out: java.io.OutputStream
   ): Unit = {
     val zipOut = new apache.ZipOutputStream(out)
@@ -125,7 +133,7 @@ object zip {
         sources,
         excludePatterns,
         includePatterns,
-        (path, sub) => makeZipEntry(path, sub, preserveMtimes, zipOut)
+        (path, sub) => makeZipEntry(path, sub, preserveMtimes, preserveLinks, zipOut)
       )
       zipOut.finish()
     } finally {
@@ -146,17 +154,25 @@ object zip {
     !isExcluded && isIncluded
   }
 
-  private def toFileType(file: os.Path): apache.PermissionUtils.FileType = {
-    if (os.isLink(file)) apache.PermissionUtils.FileType.SYMLINK
-    else if (os.isFile(file)) apache.PermissionUtils.FileType.REGULAR_FILE
-    else if (os.isDir(file)) apache.PermissionUtils.FileType.DIR
+  private def toFileType(
+      file: os.Path,
+      followLinks: Boolean = false
+  ): apache.PermissionUtils.FileType = {
+    val attrs = if (followLinks)
+      Files.readAttributes(file.toNIO, classOf[BasicFileAttributes])
+    else Files.readAttributes(file.toNIO, classOf[BasicFileAttributes], LinkOption.NOFOLLOW_LINKS)
+
+    if (attrs.isSymbolicLink()) apache.PermissionUtils.FileType.SYMLINK
+    else if (attrs.isRegularFile()) apache.PermissionUtils.FileType.REGULAR_FILE
+    else if (attrs.isDirectory()) apache.PermissionUtils.FileType.DIR
     else apache.PermissionUtils.FileType.OTHER
   }
 
   private def makeZipEntry(
       file: os.Path,
       sub: os.SubPath,
       preserveMtimes: Boolean,
+      preserveLinks: Boolean,
       zipOut: apache.ZipOutputStream
   ) = {
     val zipEntry = new apache.ZipEntry(sub.toString)
@@ -166,14 +182,14 @@ object zip {
 
     if (!scala.util.Properties.isWin) {
       val mode = apache.PermissionUtils.modeFromPermissions(
-        os.perms(file, followLinks = false).toSet(),
-        toFileType(file)
+        os.perms(file, followLinks = !preserveLinks).toSet(),
+        toFileType(file, followLinks = !preserveLinks)
       )
       zipEntry.setUnixMode(mode)
     }
 
     val fis =
-      if (!scala.util.Properties.isWin && os.isLink(file))
+      if (preserveLinks && !scala.util.Properties.isWin && os.isLink(file))
         Some(new java.io.ByteArrayInputStream(os.readLink(file).toString().getBytes()))
       else if (os.isFile(file)) Some(os.read.inputStream(file))
       else None
@@ -201,7 +217,8 @@ object zip {
       excludePatterns: Seq[Regex] = List(),
       includePatterns: Seq[Regex] = List(),
       preserveMtimes: Boolean = false,
-      compressionLevel: Int = java.util.zip.Deflater.DEFAULT_COMPRESSION
+      compressionLevel: Int = java.util.zip.Deflater.DEFAULT_COMPRESSION,
+      preserveLinks: Boolean = false
   ): geny.Writable = {
     (outputStream: java.io.OutputStream) =>
       {
@@ -211,6 +228,7 @@ object zip {
           includePatterns,
           preserveMtimes,
           compressionLevel,
+          preserveLinks,
           outputStream
         )
       }

os/test/src/ZipOpTests.scala

@@ -191,26 +191,29 @@ object ZipOpTests extends TestSuite {
       def prepare(
           wd: os.Path,
           zipStream: Boolean = false,
-          unzipStream: Boolean = false
+          unzipStream: Boolean = false,
+          preserveLinks: Boolean = false
       ) = {
         val zipFileName = "zipped.zip"
         val source = wd / "folder2"
+        val link = os.rel / "nestedA" / "link.txt"
         if (!scala.util.Properties.isWin) {
           os.perms.set(source / "nestedA" / "a.txt", os.PermSet.fromString("rw-rw-rw-"))
-          os.symlink(source / "nestedA" / "link.txt", os.rel / "a.txt")
+          os.symlink(source / link, os.rel / "a.txt")
         }
 
         val zipped =
           if (zipStream) {
             os.write(
               wd / zipFileName,
-              os.zip.stream(sources = List(source))
+              os.zip.stream(sources = List(source), preserveLinks = preserveLinks)
             )
             wd / zipFileName
           } else {
             os.zip(
               dest = wd / zipFileName,
-              sources = List(source)
+              sources = List(source),
+              preserveLinks = preserveLinks
             )
           }
 
@@ -228,56 +231,92 @@ object ZipOpTests extends TestSuite {
             )
           }
 
-        (source, unzipped)
+        (source, unzipped, link)
       }
 
       def walkRel(p: os.Path) = os.walk(p).map(_.relativeTo(p))
 
       test("zip") - prep { wd =>
         if (!scala.util.Properties.isWin) {
-          val (source, unzipped) = prepare(wd)
+          val (source, unzipped, link) = prepare(wd, preserveLinks = false)
 
           assert(walkRel(source).toSet == walkRel(unzipped).toSet)
           assert(os.walk.stream(source)
             .filter(!os.isLink(_))
             .forall(p => os.perms(p) == os.perms(unzipped / p.relativeTo(source))))
-          assert(
-            os.walk.stream(source)
-              .filter(os.isLink(_))
-              .forall { p =>
-                val unzippedLink = unzipped / p.relativeTo(source)
-                os.isLink(unzippedLink) &&
-                os.readLink(p) == os.readLink(unzippedLink)
-              }
-          )
+
+          val unzippedLink = unzipped / link
+          assert(os.isFile(unzippedLink))
+          assert(os.read(os.readLink.absolute(source / link)) == os.read(unzippedLink))
+        }
+      }
+
+      test("zipPreserveLinks") - prep { wd =>
+        if (!scala.util.Properties.isWin) {
+          val (source, unzipped, link) = prepare(wd, preserveLinks = true)
+
+          assert(walkRel(source).toSet == walkRel(unzipped).toSet)
+          assert(os.walk.stream(source)
+            .filter(!os.isLink(_))
+            .forall(p => os.perms(p) == os.perms(unzipped / p.relativeTo(source))))
+
+          val unzippedLink = unzipped / link
+          assert(os.isLink(unzippedLink))
+          assert(os.readLink(source / link) == os.readLink(unzippedLink))
         }
       }
 
       test("zipStream") - prep { wd =>
         if (!scala.util.Properties.isWin) {
-          val (source, unzipped) = prepare(wd, zipStream = true)
+          val (source, unzipped, link) = prepare(wd, zipStream = true, preserveLinks = false)
+
+          assert(walkRel(source).toSet == walkRel(unzipped).toSet)
+          assert(os.walk.stream(source)
+            .filter(!os.isLink(_))
+            .forall(p => os.perms(p) == os.perms(unzipped / p.relativeTo(source))))
+
+          val unzippedLink = unzipped / link
+          assert(os.isFile(unzippedLink))
+          assert(os.read(os.readLink.absolute(source / link)) == os.read(unzippedLink))
+        }
+      }
+
+      test("zipStreamPreserveLinks") - prep { wd =>
+        if (!scala.util.Properties.isWin) {
+          val (source, unzipped, link) = prepare(wd, zipStream = true, preserveLinks = true)
 
           assert(walkRel(source).toSet == walkRel(unzipped).toSet)
           assert(os.walk.stream(source)
             .filter(!os.isLink(_))
             .forall(p => os.perms(p) == os.perms(unzipped / p.relativeTo(source))))
-          assert(
-            os.walk.stream(source)
-              .filter(os.isLink(_))
-              .forall { p =>
-                val unzippedLink = unzipped / p.relativeTo(source)
-                os.isLink(unzippedLink) &&
-                os.readLink(p) == os.readLink(unzippedLink)
-              }
-          )
+
+          val unzippedLink = unzipped / link
+          assert(os.isLink(unzippedLink))
+          assert(os.readLink(source / link) == os.readLink(unzippedLink))
+        }
+      }
+
+      test("unzipStreamWithLinks") - prep { wd =>
+        if (!scala.util.Properties.isWin) {
+          val (source, unzipped, link) = prepare(wd, unzipStream = true, preserveLinks = true)
+
+          assert(walkRel(source).toSet == walkRel(unzipped).toSet)
+
+          val unzippedLink = unzipped / link
+          assert(os.isFile(unzippedLink))
+          assert(os.readLink(source / link).toString == os.read(unzippedLink))
         }
       }
 
       test("unzipStream") - prep { wd =>
         if (!scala.util.Properties.isWin) {
-          val (source, unzipped) = prepare(wd, unzipStream = true)
+          val (source, unzipped, link) = prepare(wd, unzipStream = true, preserveLinks = false)
 
           assert(walkRel(source).toSet == walkRel(unzipped).toSet)
+
+          val unzippedLink = unzipped / link
+          assert(os.isFile(unzippedLink))
+          assert(os.read(os.readLink.absolute(source / link)) == os.read(unzippedLink))
         }
       }
     }