Add Directory#liveList and make Directory#list() direct

Also move the LiveData outside Directory.Content. A lot of code doesn't
care about Directory content in two seconds, they want to know it now.

Also, the LiveData returned is one of the annoying one where the content
isn't correct until someone observes it. This makes more sense this way.

5 files changed, 68 insertions, 71 deletions

diff --git a/app/src/main/java/org/the_jk/cleversync/io/Directory.kt b/app/src/main/java/org/the_jk/cleversync/io/Directory.kt
index 2273f3e..cf47db9 100644
--- a/app/src/main/java/org/the_jk/cleversync/io/Directory.kt
+++ b/app/src/main/java/org/the_jk/cleversync/io/Directory.kt
@@ -6,10 +6,11 @@ interface Directory {
     val name: String
 
     fun list(): Content
+    fun liveList(): LiveData<Content>
 
     data class Content(
-        val directories: LiveData<List<Directory>>,
-        val files: LiveData<List<File>>,
-        val links: LiveData<List<Link>>,
+        val directories: List<Directory>,
+        val files: List<File>,
+        val links: List<Link>,
     )
 }
diff --git a/app/src/main/java/org/the_jk/cleversync/io/ModifiableDirectory.kt b/app/src/main/java/org/the_jk/cleversync/io/ModifiableDirectory.kt
index 43efa8f..f056bf5 100644
--- a/app/src/main/java/org/the_jk/cleversync/io/ModifiableDirectory.kt
+++ b/app/src/main/java/org/the_jk/cleversync/io/ModifiableDirectory.kt
@@ -4,6 +4,7 @@ import androidx.lifecycle.LiveData
 
 interface ModifiableDirectory : Directory {
     fun modifiableList(): Content
+    fun modifiableLiveList(): LiveData<Content>
 
     fun createDirectory(name: String): ModifiableDirectory
     fun createFile(name: String): ModifiableFile
@@ -14,8 +15,8 @@ interface ModifiableDirectory : Directory {
     fun removeLink(name: String): Boolean
 
     data class Content(
-        val directories: LiveData<List<ModifiableDirectory>>,
-        val files: LiveData<List<ModifiableFile>>,
-        val links: LiveData<List<ModifiableLink>>,
+        val directories: List<ModifiableDirectory>,
+        val files: List<ModifiableFile>,
+        val links: List<ModifiableLink>,
     )
 }
diff --git a/app/src/main/java/org/the_jk/cleversync/io/impl/PathDirectory.kt b/app/src/main/java/org/the_jk/cleversync/io/impl/PathDirectory.kt
index fab4dcc..2df6cc4 100644
--- a/app/src/main/java/org/the_jk/cleversync/io/impl/PathDirectory.kt
+++ b/app/src/main/java/org/the_jk/cleversync/io/impl/PathDirectory.kt
@@ -31,37 +31,22 @@ internal open class PathDirectory(
         DirectoryWatcher()
     }
 
-    private val modifiableContent: ModifiableDirectory.Content by lazy {
-        val base = watcher.content
-        ModifiableDirectory.Content(
-            base.map { entries ->
-                entries.filterIsInstance<Entry.Directory>().map { entry ->
-                    PathDirectory(entry.path, pathWatcher)
-                }
-            },
-            base.map { entries ->
-                entries.filterIsInstance<Entry.File>().map { entry ->
-                    PathFile(entry.path)
-                }
-            },
-            base.map { entries ->
-                entries.filterIsInstance<Entry.Link>().map { entry ->
-                    PathLink(entry.path, pathWatcher)
-                }
-            },
-        )
+    private val modifiableLiveContent: LiveData<ModifiableDirectory.Content> by lazy {
+        watcher.content
     }
 
-    private val content: Directory.Content by lazy {
-        val base = modifiableContent
-        Directory.Content(
-            base.directories.map { it },
-            base.files.map { it },
-            base.links.map { it },
-        )
+    private val liveContent: LiveData<Directory.Content> by lazy {
+        modifiableLiveContent.map {
+            Directory.Content(
+                it.directories,
+                it.files,
+                it.links,
+            )
+        }
     }
 
-    override fun modifiableList() = modifiableContent
+    override fun modifiableList() = makeContent(path.listDirectoryEntries())
+    override fun modifiableLiveList() = modifiableLiveContent
 
     override fun createDirectory(name: String): ModifiableDirectory {
         val path = path.resolve(name)
@@ -99,30 +84,29 @@ internal open class PathDirectory(
     override val name: String
         get() = path.name
 
-    override fun list() = content
+    override fun list(): Directory.Content {
+        val modifiable = modifiableList()
+        return Directory.Content(modifiable.directories, modifiable.files, modifiable.links)
+    }
+
+    override fun liveList() = liveContent
 
     override fun equals(other: Any?) = other is PathDirectory && other.path == path
     override fun hashCode() = path.hashCode()
 
-    private sealed class Entry(val path: Path) {
-        class Directory(path: Path) : Entry(path)
-        class File(path: Path) : Entry(path)
-        class Link(path: Path) : Entry(path)
-    }
-
     private inner class DirectoryWatcher : PathWatcher.Delegate {
-        val content: LiveData<List<Entry>>
+        val content: LiveData<ModifiableDirectory.Content>
             get() = _content
 
         @AnyThread
         override fun update(added: List<Path>, removed: List<Path>) {
             try {
-                _content.postValue(mapEntries(path.listDirectoryEntries()))
+                _content.postValue(makeContent(path.listDirectoryEntries()))
             } catch (ignored: NoSuchFileException) {
             }
         }
 
-        private val _content = object : MutableLiveData<List<Entry>>() {
+        private val _content = object : MutableLiveData<ModifiableDirectory.Content>() {
             override fun onActive() {
                 setup()
             }
@@ -135,7 +119,7 @@ internal open class PathDirectory(
         private fun setup() {
             val entries = path.listDirectoryEntries()
             pathWatcher.add(path, this)
-            _content.value = mapEntries(entries)
+            _content.value = makeContent(entries)
         }
 
         private fun clear() {
@@ -143,19 +127,19 @@ internal open class PathDirectory(
         }
     }
 
-    companion object {
-        private fun mapEntries(entries: List<Path>): List<Entry> {
-            return entries.mapNotNull {
-                if (it.isDirectory(LinkOption.NOFOLLOW_LINKS)) {
-                    Entry.Directory(it)
-                } else if (it.isRegularFile(LinkOption.NOFOLLOW_LINKS)) {
-                    Entry.File(it)
-                } else if (it.isSymbolicLink()) {
-                    Entry.Link(it)
-                } else {
-                    null
-                }
+    private fun makeContent(entries: List<Path>): ModifiableDirectory.Content {
+        val directories = mutableListOf<ModifiableDirectory>()
+        val files = mutableListOf<ModifiableFile>()
+        val links = mutableListOf<ModifiableLink>()
+        entries.forEach {
+            if (it.isDirectory(LinkOption.NOFOLLOW_LINKS)) {
+                directories.add(PathDirectory(it, pathWatcher))
+            } else if (it.isRegularFile(LinkOption.NOFOLLOW_LINKS)) {
+                files.add(PathFile(it))
+            } else if (it.isSymbolicLink()) {
+                links.add(PathLink(it, pathWatcher))
             }
         }
+        return ModifiableDirectory.Content(directories, files, links)
     }
 }
diff --git a/app/src/test/java/org/the_jk/cleversync/LocalTreeTest.kt b/app/src/test/java/org/the_jk/cleversync/LocalTreeTest.kt
index d9a9bd8..951fd62 100644
--- a/app/src/test/java/org/the_jk/cleversync/LocalTreeTest.kt
+++ b/app/src/test/java/org/the_jk/cleversync/LocalTreeTest.kt
@@ -29,9 +29,17 @@ class LocalTreeTest {
     @Test
     fun empty() {
         val content = tree.list()
-        assertThat(content.directories.safeValue()).isEmpty()
-        assertThat(content.files.safeValue()).isEmpty()
-        assertThat(content.links.safeValue()).isEmpty()
+        assertThat(content.directories).isEmpty()
+        assertThat(content.files).isEmpty()
+        assertThat(content.links).isEmpty()
+    }
+
+    @Test
+    fun emptyLive() {
+        val content = tree.liveList().safeValue()
+        assertThat(content?.directories).isEmpty()
+        assertThat(content?.files).isEmpty()
+        assertThat(content?.links).isEmpty()
     }
 
     @Test
@@ -39,21 +47,21 @@ class LocalTreeTest {
         val foo = tree.createDirectory("foo")
         assertThat(foo.name).isEqualTo("foo")
         val fooContent = foo.list()
-        assertThat(fooContent.directories.safeValue()).isEmpty()
-        assertThat(fooContent.files.safeValue()).isEmpty()
-        assertThat(fooContent.links.safeValue()).isEmpty()
+        assertThat(fooContent.directories).isEmpty()
+        assertThat(fooContent.files).isEmpty()
+        assertThat(fooContent.links).isEmpty()
         val content = tree.list()
-        assertThat(content.directories.safeValue()).contains(foo)
-        assertThat(content.files.safeValue()).isEmpty()
-        assertThat(content.links.safeValue()).isEmpty()
+        assertThat(content.directories).contains(foo)
+        assertThat(content.files).isEmpty()
+        assertThat(content.links).isEmpty()
     }
 
     @Test
     fun observeCreateDirectory() {
-        val content = tree.list()
+        val content = tree.liveList()
         var dir: Directory? = null
-        content.directories.observeForever { list ->
-            if (list.size == 1) dir = list[0]
+        content.observeForever {
+            if (it.directories.size == 1) dir = it.directories[0]
         }
         tree.createDirectory("foo")
         while (dir == null) {
@@ -66,11 +74,11 @@ class LocalTreeTest {
     fun createFile() {
         val foo = tree.createFile("foo")
         // Files are not created until you write to them.
-        assertThat(tree.list().files.safeValue()).isEmpty()
+        assertThat(tree.list().files).isEmpty()
         foo.write().use { os ->
             os.write(byteArrayOf(1, 2, 3, 4))
         }
-        assertThat(tree.list().files.safeValue()).contains(foo)
+        assertThat(tree.list().files).contains(foo)
         assertThat(foo.size).isEqualTo(4.toULong())
         foo.read().use {
             assertThat(it.readBytes()).isEqualTo(byteArrayOf(1, 2, 3, 4))
@@ -88,7 +96,7 @@ class LocalTreeTest {
             assertThat(foo.size).isEqualTo(4.toULong())
         }
         assertThat(foo.size).isEqualTo(1.toULong())
-        assertThat(tree.list().files.safeValue()).hasSize(1)
+        assertThat(tree.list().files).hasSize(1)
         foo.read().use {
             assertThat(it.readBytes()).isEqualTo(byteArrayOf(127))
         }
diff --git a/detekt.yaml b/detekt.yaml
index 6b5d389..539a82f 100644
--- a/detekt.yaml
+++ b/detekt.yaml
@@ -7,3 +7,6 @@ naming:
   PackageNaming:
     packagePattern: '[a-z]+(\.[a-z][_A-Za-z0-9]*)*'
 
+complexity:
+  TooManyFunctions:
+    active: false