Merge remote-tracking branch 'origin/main'

Author: github-actions

app/src/main/java/com/example/android/architecture/blueprints/todoapp/data/DefaultTasksRepository.kt

@@ -41,7 +41,7 @@ class DefaultTasksRepository(
 
     override suspend fun createTask(title: String, description: String): Task {
         val task = Task(title = title, description = description)
-        tasksDao.insertTask(task.toLocalModel())
+        tasksDao.insertTask(task.toLocal())
         saveTasksToNetwork()
         return task
     }
@@ -52,7 +52,7 @@ class DefaultTasksRepository(
             description = description
         ) ?: throw Exception("Task (id $taskId) not found")
 
-        tasksDao.insertTask(task.toLocalModel())
+        tasksDao.insertTask(task.toLocal())
         saveTasksToNetwork()
     }
 
@@ -61,7 +61,7 @@ class DefaultTasksRepository(
             loadTasksFromNetwork()
         }
         return withContext(coroutineDispatcher) {
-            tasksDao.getTasks().toExternalModels()
+            tasksDao.getTasks().toExternal()
         }
     }
 
@@ -72,7 +72,7 @@ class DefaultTasksRepository(
     override fun getTasksStream(): Flow<List<Task>> {
         return tasksDao.observeTasks().map { tasks ->
             withContext(coroutineDispatcher) {
-                tasks.toExternalModels()
+                tasks.toExternal()
             }
         }
     }
@@ -82,7 +82,7 @@ class DefaultTasksRepository(
     }
 
     override fun getTaskStream(taskId: String): Flow<Task?> {
-        return tasksDao.observeTaskById(taskId).map { it.toExternalModel() }
+        return tasksDao.observeTaskById(taskId).map { it.toExternal() }
     }
 
     /**
@@ -95,7 +95,7 @@ class DefaultTasksRepository(
         if (forceUpdate) {
             loadTasksFromNetwork()
         }
-        return tasksDao.getTaskById(taskId)?.toExternalModel()
+        return tasksDao.getTaskById(taskId)?.toExternal()
     }
 
     override suspend fun completeTask(taskId: String) {
@@ -141,15 +141,15 @@ class DefaultTasksRepository(
 
             tasksDao.deleteTasks()
             remoteTasks.forEach { task ->
-                tasksDao.insertTask(task.toTaskEntity())
+                tasksDao.insertTask(task.toLocal())
             }
         }
     }
 
     private suspend fun saveTasksToNetwork() {
         withContext(coroutineDispatcher) {
             val localTasks = tasksDao.getTasks()
-            tasksNetworkDataSource.saveTasks(localTasks.toNetworkModels())
+            tasksNetworkDataSource.saveTasks(localTasks.toNetwork())
         }
     }
 }

app/src/main/java/com/example/android/architecture/blueprints/todoapp/data/ModelMappingExt.kt

@@ -24,28 +24,28 @@ import com.example.android.architecture.blueprints.todoapp.data.source.network.T
  * Data model mapping extension functions. There are three model types:
  *
  * - Task: External model exposed to other layers in the architecture.
- * Obtained using `toExternalModel`.
+ * Obtained using `toExternal`.
  *
  * - NetworkTask: Internal model used to represent a task from the network. Obtained using
- * `toNetworkModel`.
+ * `toNetwork`.
  *
  * - LocalTask: Internal model used to represent a task stored locally in a database. Obtained
- * using `toLocalModel`.
+ * using `toLocal`.
  *
  */
 
 // External to local
-fun Task.toLocalModel() = LocalTask(
+fun Task.toLocal() = LocalTask(
     id = id,
     title = title,
     description = description,
     isCompleted = isCompleted,
 )
 
-fun List.toLocalModels() = map(Task::toLocalModel)
+fun List.toLocal() = map(Task::toLocal)
 
 // Local to External
-fun LocalTask.toExternalModel() = Task(
+fun LocalTask.toExternal() = Task(
     id = id,
     title = title,
     description = description,
@@ -55,38 +55,38 @@ fun LocalTask.toExternalModel() = Task(
 // Note: JvmName is used to provide a unique name for each extension function with the same name.
 // Without this, type erasure will cause compiler errors because these methods will have the same
 // signature on the JVM.
-@JvmName("taskEntitiesToExternalModels")
-fun List.toExternalModels() = map(LocalTask::toExternalModel)
+@JvmName("localToExternal")
+fun List.toExternal() = map(LocalTask::toExternal)
 
 // Network to Local
-fun NetworkTask.toTaskEntity() = LocalTask(
+fun NetworkTask.toLocal() = LocalTask(
     id = id,
     title = title,
     description = shortDescription,
     isCompleted = (status == TaskStatus.COMPLETE),
 )
 
-@JvmName("networkTasksToTaskEntities")
-fun List.toTaskEntities() = map(NetworkTask::toTaskEntity)
+@JvmName("networkToLocal")
+fun List.toLocal() = map(NetworkTask::toLocal)
 
 // Local to Network
-fun LocalTask.toNetworkModel() = NetworkTask(
+fun LocalTask.toNetwork() = NetworkTask(
     id = id,
     title = title,
     shortDescription = description,
     status = if (isCompleted) { TaskStatus.COMPLETE } else { TaskStatus.ACTIVE }
 )
 
-fun List.toNetworkModels() = map(LocalTask::toNetworkModel)
+fun List.toNetwork() = map(LocalTask::toNetwork)
 
 // External to Network
-fun Task.toNetworkModel() = toLocalModel().toNetworkModel()
+fun Task.toNetwork() = toLocal().toNetwork()
 
-@JvmName("tasksToNetworkTasks")
-fun List.toNetworkModels() = map(Task::toNetworkModel)
+@JvmName("externalToNetwork")
+fun List.toNetwork() = map(Task::toNetwork)
 
 // Network to External
-fun NetworkTask.toExternalModel() = toTaskEntity().toExternalModel()
+fun NetworkTask.toExternal() = toLocal().toExternal()
 
-@JvmName("networkTasksToTasks")
-fun List.toExternalModels() = map(NetworkTask::toExternalModel)
+@JvmName("networkToExternal")
+fun List.toExternal() = map(NetworkTask::toExternal)

app/src/test/java/com/example/android/architecture/blueprints/todoapp/data/DefaultTasksRepositoryTest.kt

@@ -36,8 +36,8 @@ class DefaultTasksRepositoryTest {
     private val task2 = Task(title = "Title2", description = "Description2")
     private val task3 = Task(title = "Title3", description = "Description3")
     private val newTask = Task(title = "Title new", description = "Description new")
-    private val networkTasks = listOf(task1, task2).toNetworkModels().sortedBy { it.id }
-    private val localTasks = listOf(task3.toLocalModel()).sortedBy { it.id }
+    private val networkTasks = listOf(task1, task2).toNetwork().sortedBy { it.id }
+    private val localTasks = listOf(task3.toLocal()).sortedBy { it.id }
 
     private val newTasks = listOf(newTask).sortedBy { it.id }
     private lateinit var tasksNetworkDataSource: FakeNetworkDataSource
@@ -81,7 +81,7 @@ class DefaultTasksRepositoryTest {
         val initial = tasksRepository.getTasks(forceUpdate = true)
 
         // Change the remote data source
-        tasksNetworkDataSource.tasks = newTasks.toNetworkModels().toMutableList()
+        tasksNetworkDataSource.tasks = newTasks.toNetwork().toMutableList()
 
         // Load the tasks again without forcing a refresh
         val second = tasksRepository.getTasks()
@@ -97,21 +97,21 @@ class DefaultTasksRepositoryTest {
         val tasks = tasksRepository.getTasks(true)
 
         // Then tasks are loaded from the remote data source
-        assertThat(tasks).isEqualTo(networkTasks.toExternalModels())
+        assertThat(tasks).isEqualTo(networkTasks.toExternal())
     }
 
     @Test
     fun saveTask_savesToLocalAndRemote() = runTest {
         // Make sure newTask is not in the remote or local datasources
-        assertThat(tasksNetworkDataSource.tasks).doesNotContain(newTask.toNetworkModel())
-        assertThat(tasksLocalDataSource.tasks).doesNotContain(newTask.toLocalModel())
+        assertThat(tasksNetworkDataSource.tasks).doesNotContain(newTask.toNetwork())
+        assertThat(tasksLocalDataSource.tasks).doesNotContain(newTask.toLocal())
 
         // When a task is saved to the tasks repository
         val newTask = tasksRepository.createTask(newTask.title, newTask.description)
 
         // Then the remote and local sources are called
-        assertThat(tasksNetworkDataSource.tasks).contains(newTask.toNetworkModel())
-        assertThat(tasksLocalDataSource.tasks?.contains(newTask.toLocalModel()))
+        assertThat(tasksNetworkDataSource.tasks).contains(newTask.toNetwork())
+        assertThat(tasksLocalDataSource.tasks?.contains(newTask.toLocal()))
     }
 
     @Test
@@ -120,7 +120,7 @@ class DefaultTasksRepositoryTest {
         val tasks = tasksRepository.getTasks()
 
         // Set a different list of tasks in REMOTE
-        tasksNetworkDataSource.tasks = newTasks.toNetworkModels().toMutableList()
+        tasksNetworkDataSource.tasks = newTasks.toNetwork().toMutableList()
 
         // But if tasks are cached, subsequent calls load from cache
         val cachedTasks = tasksRepository.getTasks()
@@ -151,7 +151,7 @@ class DefaultTasksRepositoryTest {
             tasksNetworkDataSource.tasks = null
 
             // The repository fetches from the local source
-            assertThat(tasksRepository.getTasks()).isEqualTo(localTasks.toExternalModels())
+            assertThat(tasksRepository.getTasks()).isEqualTo(localTasks.toExternal())
         }
 
     @Test(expected = Exception::class)
@@ -171,8 +171,8 @@ class DefaultTasksRepositoryTest {
         // Forcing an update will fetch tasks from remote
         val newTasks = tasksRepository.getTasks(true)
 
-        assertThat(newTasks).isEqualTo(networkTasks.toExternalModels())
-        assertThat(newTasks).isEqualTo(tasksLocalDataSource.tasks?.toExternalModels())
+        assertThat(newTasks).isEqualTo(networkTasks.toExternal())
+        assertThat(newTasks).isEqualTo(tasksLocalDataSource.tasks?.toExternal())
         assertThat(tasksLocalDataSource.tasks).isEqualTo(initialLocal)
     }
 
@@ -210,11 +210,11 @@ class DefaultTasksRepositoryTest {
     @Test
     fun getTask_repositoryCachesAfterFirstApiCall() = runTest {
         // Obtain a task from the local data source
-        tasksLocalDataSource.tasks = mutableListOf(task1.toLocalModel())
+        tasksLocalDataSource.tasks = mutableListOf(task1.toLocal())
         val initial = tasksRepository.getTask(task1.id)
 
         // Change the tasks on the remote
-        tasksNetworkDataSource.tasks = newTasks.toNetworkModels().toMutableList()
+        tasksNetworkDataSource.tasks = newTasks.toNetwork().toMutableList()
 
         // Obtain the same task again
         val second = tasksRepository.getTask(task1.id)
@@ -226,12 +226,12 @@ class DefaultTasksRepositoryTest {
     @Test
     fun getTask_forceRefresh() = runTest {
         // Trigger the repository to load data, which loads from remote and caches
-        tasksNetworkDataSource.tasks = mutableListOf(task1.toNetworkModel())
+        tasksNetworkDataSource.tasks = mutableListOf(task1.toNetwork())
         val task1FirstTime = tasksRepository.getTask(task1.id, forceUpdate = true)
         assertThat(task1FirstTime?.id).isEqualTo(task1.id)
 
         // Configure the remote data source to return a different task
-        tasksNetworkDataSource.tasks = mutableListOf(task2.toNetworkModel())
+        tasksNetworkDataSource.tasks = mutableListOf(task2.toNetwork())
 
         // Force refresh
         val task1SecondTime = tasksRepository.getTask(task1.id, true)
@@ -246,8 +246,8 @@ class DefaultTasksRepositoryTest {
     fun clearCompletedTasks() = runTest {
         val completedTask = task1.copy(isCompleted = true)
         tasksLocalDataSource.tasks = mutableListOf(
-            completedTask.toLocalModel(),
-            task2.toLocalModel()
+            completedTask.toLocal(),
+            task2.toLocal()
         )
         tasksRepository.clearCompletedTasks()