FileUtils: refactoring and unit tests (#388)

.gitignore

@@ -12,3 +12,4 @@
 *.tab
 *.tab.values.at
 misc.xml
+/htmlReport

app/src/main/java/dev/arkbuilders/navigator/data/utils/DevicePathsExtractor.kt

@@ -0,0 +1,10 @@
+package dev.arkbuilders.navigator.data.utils
+
+import java.nio.file.Path
+
+enum class Sorting {
+    DEFAULT, NAME, SIZE, LAST_MODIFIED, TYPE
+}
+interface DevicePathsExtractor {
+    fun listDevices(): List<Path>
+}

app/src/main/java/dev/arkbuilders/navigator/data/utils/DevicePathsExtractorImpl.kt

@@ -0,0 +1,26 @@
+package dev.arkbuilders.navigator.data.utils
+
+import dev.arkbuilders.navigator.presentation.App
+import java.nio.file.Path
+import javax.inject.Inject
+
+class DevicePathsExtractorImpl @Inject constructor(
+    private val appInstance: App
+) : DevicePathsExtractor {
+
+    override fun listDevices(): List<Path> =
+        appInstance
+            .getExternalFilesDirs(null)
+            .toList()
+            .filterNotNull()
+            .filter { it.exists() }
+            .map {
+                it.toPath().toRealPath()
+                    .takeWhile { part ->
+                        part != ANDROID_DIRECTORY
+                    }
+                    .fold(ROOT_PATH) { parent, child ->
+                        parent.resolve(child)
+                    }
+            }
+}

app/src/main/java/dev/arkbuilders/navigator/data/utils/PathExt.kt

@@ -0,0 +1,58 @@
+package dev.arkbuilders.navigator.data.utils
+
+import java.nio.file.Path
+import java.nio.file.Paths
+import kotlin.io.path.exists
+import kotlin.io.path.extension
+import kotlin.io.path.nameWithoutExtension
+import kotlin.io.path.notExists
+
+val ROOT_PATH: Path = Paths.get("/")
+
+val ANDROID_DIRECTORY: Path = Paths.get("Android")
+
+fun Path.findNotExistCopyName(name: Path): Path {
+    val originalNamePath = this.resolve(name.fileName)
+    if (originalNamePath.notExists())
+        return originalNamePath
+
+    var filesCounter = 1
+
+    val formatNameWithCounter =
+        "${name.nameWithoutExtension}_$filesCounter.${name.extension}"
+
+    var newPath = this.resolve(formatNameWithCounter)
+
+    while (newPath.exists()) {
+        newPath = this.resolve(formatNameWithCounter)
+        filesCounter++
+    }
+    return newPath
+}
+
+fun findLongestCommonPrefix(paths: List<Path>): Path {
+    if (paths.isEmpty()) {
+        throw IllegalArgumentException(
+            "Can't search for common prefix among empty collection"
+        )
+    }
+
+    if (paths.size == 1) {
+        return paths.first()
+    }
+
+    return tailrec(ROOT_PATH, paths).first
+}
+
+private fun tailrec(prefix: Path, paths: List<Path>): Pair<Path, List<Path>> {
+    val grouped = paths.groupBy { it.getName(0) }
+    if (grouped.size > 1) {
+        return prefix to paths
+    }
+
+    val resolvedPrefix = prefix.resolve(grouped.keys.first())
+    val shortened = grouped.values.first()
+        .map { resolvedPrefix.relativize(it) }
+
+    return tailrec(resolvedPrefix, shortened)
+}

app/src/main/java/dev/arkbuilders/navigator/di/AppComponent.kt

@@ -12,6 +12,7 @@ import dev.arkbuilders.navigator.presentation.App
 import dev.arkbuilders.navigator.presentation.dialog.ExplainPermsDialog
 import dev.arkbuilders.navigator.presentation.dialog.RootPickerDialogFragment
 import dev.arkbuilders.navigator.presentation.dialog.edittags.EditTagsDialogPresenter
+import dev.arkbuilders.navigator.presentation.dialog.rootsscan.RootsScanDialogPresenter
 import dev.arkbuilders.navigator.presentation.dialog.sort.SortDialogPresenter
 import dev.arkbuilders.navigator.presentation.dialog.tagssort.TagsSortDialogFragment
 import dev.arkbuilders.navigator.presentation.screen.folders.FoldersFragment
@@ -55,6 +56,7 @@ interface AppComponent {
     fun inject(tagsSortDialogFragment: TagsSortDialogFragment)
     fun inject(rootPickerDialogFragment: RootPickerDialogFragment)
     fun inject(explainPermsDialog: ExplainPermsDialog)
+    fun inject(rootsScanDialogPresenter: RootsScanDialogPresenter)
 
     @Component.Factory
     interface Factory {

app/src/main/java/dev/arkbuilders/navigator/di/modules/AppModule.kt

@@ -5,6 +5,9 @@ import dagger.Module
 import dagger.Provides
 import dev.arkbuilders.navigator.data.preferences.Preferences
 import dev.arkbuilders.navigator.data.preferences.PreferencesImpl
+import dev.arkbuilders.navigator.data.utils.DevicePathsExtractor
+import dev.arkbuilders.navigator.data.utils.DevicePathsExtractorImpl
+import dev.arkbuilders.navigator.presentation.App
 import dev.arkbuilders.navigator.presentation.utils.StringProvider
 import javax.inject.Singleton
 
@@ -21,4 +24,9 @@ class AppModule {
     @Singleton
     fun provideUserPreferences(ctx: Context): Preferences =
         PreferencesImpl(ctx)
+
+    @Provides
+    @Singleton
+    fun provideDevicePathsExtractor(application: App): DevicePathsExtractor =
+        DevicePathsExtractorImpl(application)
 }

app/src/main/java/dev/arkbuilders/navigator/presentation/dialog/rootsscan/RootsScanDialogFragment.kt

@@ -9,13 +9,16 @@ import moxy.MvpBottomSheetDialogFragment
 import moxy.ktx.moxyPresenter
 import dev.arkbuilders.navigator.R
 import dev.arkbuilders.navigator.databinding.DialogRootsScanBinding
+import dev.arkbuilders.navigator.presentation.App
 import dev.arkbuilders.navigator.presentation.utils.toast
 import java.nio.file.Path
 
 class RootsScanDialogFragment : MvpBottomSheetDialogFragment(), RootsScanView {
     private lateinit var binding: DialogRootsScanBinding
     private val presenter by moxyPresenter {
-        RootsScanDialogPresenter()
+        RootsScanDialogPresenter().apply {
+            App.instance.appComponent.inject(this)
+        }
     }
 
     override fun onCreateView(

app/src/main/java/dev/arkbuilders/navigator/presentation/dialog/rootsscan/RootsScanDialogPresenter.kt

@@ -1,6 +1,7 @@
 package dev.arkbuilders.navigator.presentation.dialog.rootsscan
 
 import android.util.Log
+import dev.arkbuilders.navigator.data.utils.DevicePathsExtractor
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.ensureActive
 import kotlinx.coroutines.launch
@@ -9,16 +10,19 @@ import moxy.MvpPresenter
 import moxy.presenterScope
 import space.taran.arklib.arkFolder
 import dev.arkbuilders.navigator.data.utils.LogTags
-import dev.arkbuilders.navigator.data.utils.listDevices
 import java.nio.file.Path
 import java.util.LinkedList
 import java.util.Queue
+import javax.inject.Inject
 import kotlin.io.path.exists
 import kotlin.io.path.isDirectory
 import kotlin.io.path.listDirectoryEntries
 
 class RootsScanDialogPresenter : MvpPresenter<RootsScanView>() {
 
+    @Inject
+    lateinit var devicePathsExtractor: DevicePathsExtractor
+
     private val roots = mutableListOf<Path>()
     private val queue: Queue<Path> = LinkedList()
 
@@ -37,7 +41,7 @@ class RootsScanDialogPresenter : MvpPresenter<RootsScanView>() {
     }
 
     private fun scan() = presenterScope.launch(Dispatchers.IO) {
-        queue.addAll(listDevices())
+        queue.addAll(devicePathsExtractor.listDevices())
 
         while (queue.isNotEmpty()) {
             ensureActive()

app/src/main/java/dev/arkbuilders/navigator/presentation/screen/folders/FoldersViewModel.kt

@@ -10,8 +10,8 @@ import dagger.assisted.AssistedInject
 import dev.arkbuilders.navigator.data.PermissionsHelper
 import dev.arkbuilders.navigator.data.preferences.PreferenceKey
 import dev.arkbuilders.navigator.data.preferences.Preferences
+import dev.arkbuilders.navigator.data.utils.DevicePathsExtractor
 import dev.arkbuilders.navigator.data.utils.LogTags
-import dev.arkbuilders.navigator.data.utils.listDevices
 import org.orbitmvi.orbit.Container
 import org.orbitmvi.orbit.ContainerHost
 import org.orbitmvi.orbit.syntax.simple.intent
@@ -50,6 +50,7 @@ class FoldersViewModel(
     private val resourcesIndexRepo: ResourceIndexRepo,
     private val preferences: Preferences,
     private val permsHelper: PermissionsHelper,
+    private val devicePathsExtractor: DevicePathsExtractor
 ) : ViewModel(), ContainerHost<FoldersState, FoldersSideEffect> {
 
     override val container: Container<FoldersState, FoldersSideEffect> = container(
@@ -77,7 +78,7 @@ class FoldersViewModel(
                 )
             }
             val folders = foldersRepo.provideWithMissing()
-            devices = listDevices()
+            devices = devicePathsExtractor.listDevices()
 
             postSideEffect(FoldersSideEffect.ToastFailedPaths(folders.failed))
 
@@ -276,14 +277,16 @@ class FoldersViewModelFactory @AssistedInject constructor(
     private val resourcesIndexRepo: ResourceIndexRepo,
     private val preferences: Preferences,
     private val permsHelper: PermissionsHelper,
+    private val devicePathsExtractor: DevicePathsExtractor
 ) : ViewModelProvider.Factory {
     override fun <T : ViewModel> create(modelClass: Class<T>): T {
         return FoldersViewModel(
             rescanRoots,
             foldersRepo,
             resourcesIndexRepo,
             preferences,
-            permsHelper
+            permsHelper,
+            devicePathsExtractor
         ) as T
     }
 

app/src/test/java/dev/arkbuilders/navigator/data/utils/DevicePathsExtractorTest.kt

@@ -0,0 +1,53 @@
+package dev.arkbuilders.navigator.data.utils
+
+import dev.arkbuilders.navigator.presentation.App
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.verify
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import org.junit.runner.RunWith
+import org.mockito.junit.MockitoJUnitRunner
+import java.io.File
+import java.nio.file.Path
+import java.nio.file.Paths
+import kotlin.io.path.name
+
+@RunWith(MockitoJUnitRunner::class)
+class DevicePathsExtractorTest {
+
+    private val mockedApplication = mockk<App>()
+
+    private lateinit var testee: DevicePathsExtractor
+
+    @BeforeEach
+    fun setUp() {
+        testee = DevicePathsExtractorImpl(
+            appInstance = mockedApplication
+        )
+    }
+
+    @Test
+    fun givenApplicationAvailable_whenGetExternalFileDirs_thenReturnCorrectResult() {
+        val mockedFile = mockk<File>()
+        val files = listOf(mockedFile)
+        every { mockedApplication.getExternalFilesDirs(null) } returns files.toTypedArray()
+        every { mockedFile.exists() } returns true
+
+        val mockedPath = mockk<Path>()
+        every { mockedFile.toPath() } returns mockedPath
+        every { mockedPath.toRealPath() } returns mockedPath
+
+        val directoryIterator: MutableIterator<Path> = arrayListOf(
+            Paths.get("PATH")
+        ).iterator()
+        every { mockedPath.iterator() } returns directoryIterator
+
+        val result = testee.listDevices()
+
+        verify { mockedApplication.getExternalFilesDirs(null) }
+        assertEquals(1, result.size)
+        assertEquals("PATH", result[0].name)
+    }
+}