El detalle en el núcleo

package com.sebastiannarvaez.pokedex.data.network.dto
 
import kotlinx.serialization.SerialName
import kotlinx.serialization.Serializable
 
/**
 * La especie: lo que en el juego comparten un Pokemon y sus evoluciones.
 *
 * Aqui viven la descripcion y el genero, que PokeAPI **no** devuelve en
 * `/pokemon/{id}`. Por eso el detalle son dos peticiones y no una.
 */
@Serializable
internal data class SpeciesDto(
    val id: Int,
    @SerialName("is_legendary") val isLegendary: Boolean = false,
    @SerialName("is_mythical") val isMythical: Boolean = false,
    @SerialName("flavor_text_entries") val flavorTexts: List<FlavorTextDto> = emptyList(),
    val genera: List<GenusDto> = emptyList(),
)
 
@Serializable
internal data class FlavorTextDto(
    @SerialName("flavor_text") val text: String,
    val language: NamedRefDto,
)
 
@Serializable
internal data class GenusDto(
    val genus: String,
    val language: NamedRefDto,
)

import kotlinx.serialization.SerialName

    val types: List<TypeSlotDto> = emptyList(),
    val stats: List<StatSlotDto> = emptyList(),
)
 
@Serializable
internal data class StatSlotDto(
    @SerialName("base_stat") val baseStat: Int = 0,
    val stat: NamedRefDto,
)

import com.sebastiannarvaez.pokedex.data.network.dto.SpeciesDto

    suspend fun species(id: Int): SpeciesDto

    override suspend fun species(id: Int): SpeciesDto =
        client.get("pokemon-species/$id").body()

package com.sebastiannarvaez.pokedex.domain
 
/**
 * La ficha completa, que solo hace falta al abrir un Pokemon.
 *
 * Es un tipo distinto de `Pokemon` y no una version con campos nulos: el
 * listado nunca tiene esta informacion, y un modelo con la mitad de los campos
 * vacios obliga a preguntar en cada pantalla si estan o no.
 */
data class PokemonDetail(
    val id: Int,
    val name: String,
    val types: List<PokemonType>,
    /** En centimetros. PokeAPI lo da en decimetros. */
    val heightCm: Int,
    /** En gramos. PokeAPI lo da en hectogramos. */
    val weightG: Int,
    /** «Pokemon Semilla»: la categoria. Viene de la especie, no del Pokemon. */
    val genus: String,
    val description: String,
    val stats: List<PokemonStat>,
    val isLegendary: Boolean,
) {
    val artworkUrl: String
        get() = "https://raw.githubusercontent.com/PokeAPI/sprites/master/sprites/pokemon/other/official-artwork/$id.png"
}
 
data class PokemonStat(val kind: StatKind, val value: Int) {
    companion object {
        /** El maximo que alcanza una estadistica base en el juego. */
        const val MAXIMO = 255
    }
}
 
enum class StatKind {
    HP, ATTACK, DEFENSE, SPECIAL_ATTACK, SPECIAL_DEFENSE, SPEED;
 
    companion object {
        /** PokeAPI usa guiones: `special-attack`. */
        fun deApi(nombre: String): StatKind? = when (nombre) {
            "hp" -> HP
            "attack" -> ATTACK
            "defense" -> DEFENSE
            "special-attack" -> SPECIAL_ATTACK
            "special-defense" -> SPECIAL_DEFENSE
            "speed" -> SPEED
            else -> null
        }
    }
}

import com.sebastiannarvaez.pokedex.data.network.dto.PokemonDetailDto
import com.sebastiannarvaez.pokedex.data.network.dto.SpeciesDto
import com.sebastiannarvaez.pokedex.domain.PokemonDetail
import com.sebastiannarvaez.pokedex.domain.PokemonStat
import com.sebastiannarvaez.pokedex.domain.StatKind

    suspend fun detail(id: Int): PokemonDetail = withContext(dispatchers.io) {
        // withContext: todo el trabajo corre en el dispatcher de entrada y salida
        // (el que se inyectó en Corrutinas en commonMain), no en el hilo de la interfaz.
        coroutineScope {
            // coroutineScope: no termina hasta que terminen sus hijos. Si uno falla,
            // cancela al otro y la excepción sube: la ficha falla entera.
            val basico = async { api.detail(id) }     // arranca la petición de /pokemon/{id}…
            val especie = async { api.species(id) }   // …y, sin esperarla, la de /pokemon-species/{id}
            unirDetalle(basico.await(), especie.await())  // await() espera cada resultado y se juntan
        }
    }

A strange seed was\nplanted on its\nback at birth.\x0cThe plant sprouts\nand grows with\nthis POKéMON.

fun main() {
    val nota = "Comprar   pan\ny\tleche  "             // espacios de más, un salto de línea y un tabulador
    val patron = Regex("\\s+")                          // \s = un espacio, salto o tabulador; + = uno o más seguidos
    println(patron.containsMatchIn(nota))               // ¿hay algún tramo así?
    println(patron.findAll(nota).count())               // cuántos tramos encuentra
    println("[" + nota.replace(patron, " ") + "]")      // cada tramo, por un solo espacio
    println("[" + nota.replace(patron, " ").trim() + "]") // y sin espacios en los extremos
}

true
4
[Comprar pan y leche ]
[Comprar pan y leche]

// private + extensión: solo se ve dentro de este fichero, y se escribe como si
// fuera un método de SpeciesDto (this es la especie).
private fun SpeciesDto.textoEnEspanol(extraer: (SpeciesDto) -> List<Pair<String, String>>): String {
    val textos = extraer(this)  // la lambda saca la lista de parejas (texto, idioma)
    return textos.firstOrNull { it.second == "es" }?.first   // el primero en español…
        ?: textos.firstOrNull { it.second == "en" }?.first   // …si no hay, en inglés…
        ?: ""                                                // …y si no hay ninguno, vacío
}
 
// Es la expresión regular de arriba. \s+ ya incluye el salto de línea y el de
// página, así que los dos primeros replace no harían falta; se dejan escritos
// para quien lea esto y se pregunte de dónde salen los saltos.
private fun String.limpiarSaltos(): String =
    replace('\n', ' ')                  // salto de línea → espacio
        .replace('\u000c', ' ')         // salto de página → espacio
        .replace(Regex("\\s+"), " ")    // varios espacios seguidos → uno
        .trim()                         // y sin espacios en los extremos

    private fun unirDetalle(basico: PokemonDetailDto, especie: SpeciesDto): PokemonDetail =
        PokemonDetail(
            id = basico.id,
            name = basico.name,
            // sortedBy slot: PokeAPI numera los tipos (1 y 2) y no garantiza el orden.
            // mapNotNull: un tipo que no conocemos se descarta en vez de romper.
            types = basico.types.sortedBy { it.slot }.mapNotNull { PokemonType.deApi(it.type.name) },
            // PokeAPI mide en decimetros y hectogramos. La conversión vive aquí y no
            // en la pantalla: allí habría que escribirla dos veces (Compose y SwiftUI)
            // y una de las dos acabaría equivocándose.
            heightCm = basico.height * 10,
            weightG = basico.weight * 100,
            genus = especie.textoEnEspanol { it.genera.map { g -> g.genus to g.language.name } },
            description = especie.textoEnEspanol { it.flavorTexts.map { f -> f.text to f.language.name } }
                .limpiarSaltos(),
            // La estadística de nombre desconocido devuelve null y se salta.
            stats = basico.stats.mapNotNull { s ->
                StatKind.deApi(s.stat.name)?.let { PokemonStat(it, s.baseStat) }
            },
            // Legendario o mítico: para la ficha es la misma etiqueta.
            isLegendary = especie.isLegendary || especie.isMythical,
        )

./gradlew :shared:compileKotlinJvm

import com.sebastiannarvaez.pokedex.data.network.dto.FlavorTextDto
import com.sebastiannarvaez.pokedex.data.network.dto.GenusDto
import com.sebastiannarvaez.pokedex.data.network.dto.SpeciesDto
import com.sebastiannarvaez.pokedex.data.network.dto.StatSlotDto

    override suspend fun species(id: Int): SpeciesDto {
        if (falla) throw IOException("socket cerrado")
        return SpeciesDto(
            id = id,
            isLegendary = false,
            flavorTexts = listOf(
                FlavorTextDto("Texto en ingles.", NamedRefDto("en")),
                // Con salto de linea y salto de pagina, como los de verdad.
                FlavorTextDto("Una rara semilla\nle fue plantada\u000cal nacer.", NamedRefDto("es")),
            ),
            genera = listOf(
                GenusDto("Seed Pokemon", NamedRefDto("en")),
                GenusDto("Pokemon Semilla", NamedRefDto("es")),
            ),
        )
    }

    override suspend fun detail(id: Int): PokemonDetailDto {
        llamadasAlDetalle++
        return PokemonDetailDto(
            id = id,
            name = "pokemon-$id",
            height = 7,        // nuevo: decímetros, como los da PokeAPI
            weight = 69,       // nuevo: hectogramos
            types = (tipos[id] ?: listOf("normal")).mapIndexed { i, t ->
                TypeSlotDto(slot = i + 1, type = NamedRefDto(t))
            },
            stats = listOf(    // nuevo: dos conocidas y una que no
                StatSlotDto(baseStat = 45, stat = NamedRefDto("hp")),
                StatSlotDto(baseStat = 49, stat = NamedRefDto("attack")),
                // Una que no conocemos: no debe romper la ficha.
                StatSlotDto(baseStat = 10, stat = NamedRefDto("suerte")),
            ),
        )
    }

package com.sebastiannarvaez.pokedex.feature.detail
 
import com.sebastiannarvaez.pokedex.data.PokemonRepository
import com.sebastiannarvaez.pokedex.dobles.FakePokeApi
import com.sebastiannarvaez.pokedex.dobles.TestDispatchers
import com.sebastiannarvaez.pokedex.domain.StatKind
import kotlinx.coroutines.test.StandardTestDispatcher
import kotlinx.coroutines.test.TestCoroutineScheduler
import kotlinx.coroutines.test.runTest
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertFalse
 
class PokemonDetailTest {
 
    // El repositorio de verdad, con el doble de la API y el reloj virtual de runTest.
    private fun repo(scheduler: TestCoroutineScheduler) =
        PokemonRepository(FakePokeApi(total = 10), TestDispatchers(StandardTestDispatcher(scheduler)))
 
    @Test
    fun lasMedidasSeConviertenAUnidadesDeHumano() = runTest {
        // PokeAPI mide en decimetros y hectogramos, que no usa nadie.
        val detalle = repo(testScheduler).detail(1)
 
        assertEquals(70, detalle.heightCm)
        assertEquals(6900, detalle.weightG)
    }
 
    @Test
    fun elTextoLlegaEnEspanolYSinSaltosDeCartucho() = runTest {
        val detalle = repo(testScheduler).detail(1)
 
        assertEquals("Pokemon Semilla", detalle.genus)
        assertEquals("Una rara semilla le fue plantada al nacer.", detalle.description)
        assertFalse(detalle.description.contains('\n'))
    }
 
    @Test
    fun unaEstadisticaDesconocidaNoRompeLaFicha() = runTest {
        val detalle = repo(testScheduler).detail(1)
 
        assertEquals(listOf(StatKind.HP, StatKind.ATTACK), detalle.stats.map { it.kind })
        assertEquals(45, detalle.stats.first { it.kind == StatKind.HP }.value)
    }
}

./gradlew :shared:jvmTest --tests '*PokemonDetailTest'