Kotlin Code Smell 32 - Repeated Code
Tags: kotlin, codesmells, cleancode, programming
Published: 2023-08-24 09:10:33

---
title: Kotlin Code Smell 32 - Repeated Code
published: true
date: 2023-08-23 08:00:09 UTC
tags: kotlin,codesmells,cleancode,programming
canonical_url: https://yonatankarp.com/kotlin-code-smell-32-repeated-code
---

## Problem

- Code Duplication

- Maintainability

- [**Don't Repeat Yourself**](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself)

## Solution

1. Find repeated patterns (not repeated code).

2. Create an abstraction.

3. Parametrize abstraction calls.

4. Use composition and avoid inheritance.

5. Unit test the new abstraction.

## Sample Code

### Wrong

```kotlin
class WordProcessor(var text: String = "") {
    fun replaceText(patternToFind: String, textToReplace: String) {
        text = "<<< ${text.replace(patternToFind, textToReplace} >>>"
    }
}

class Obfuscator(var text: String = "") {
    fun obfuscate(patternToFind: String, textToReplace: String) {
        text = text.lowercase().replace(patternToFind, textToReplace)
    }
}

```

### Right

```kotlin
class TextReplacer {
    fun replace(
        patternToFind: String,
        textToReplace: String,
        subject: String,
        replaceFunction: (String, String, String) -> String,
        postProcessClosure: (String) -> String
    ): String =
        replaceFunction(patternToFind, textToReplace, subject)
            .let(postProcessClosure)
}

class WordProcessor(private var text: String = "") {
    fun replaceText(patternToFind: String, textToReplace: String) {
        text = TextReplacer()
            .replace(
                patternToFind,
                textToReplace,
                text,
                replaceFunction = { pattern, replace, subject ->
                    subject.replace(pattern, replace)
                },
                postProcessClosure = { "<<< $it >>>" }
            )
    }
}

class Obfuscator(private var text: String = "") {
    fun obfuscate(patternToFind: String, textToReplace: String) {
        text = TextReplacer()
            .replace(
                patternToFind,
                textToReplace,
                text,
                replaceFunction = { pattern, replace, subject ->
                    subject.replace(pattern, replace, ignoreCase = true)
                },
                postProcessClosure = { it.lowercase() }
            )
    }
}

```

## Conclusion

Repeated code is always a smell. Copying and pasting code is always a shame. With our refactoring tools, we need to accept the challenge of removing duplication and trust our tests as a safety net.

* * *

I hope you enjoyed this journey and learned something new. If you want to stay updated with my latest thoughts and ideas, feel free to register for my [**newsletter**](https://yonatankarp.com/newsletter). You can also find me on [**LinkedIn**](https://www.linkedin.com/in/yonatankarp/) or [**Twitter**](https://twitter.com/yonatan_karp). Let's stay connected and keep the conversation going!

* * *

## Credits

- [Code Smell 46 - Repeated Code](https://maximilianocontieri.com/code-smell-46-repeated-code) by [Maxi Contieri](https://hashnode.com/@mcsee)