Update 2019-10-21-dry.md

maciej-nowak · web-flow · commit d35af3b33f46 · 2019-07-12T15:46:56.000+02:00
diff --git a/_drafts/2019-10-21-dry.md b/_drafts/2019-10-21-dry.md
@@ -21,14 +21,364 @@ Nie warto na siłę próbować implementować zasadę `DRY` ponieważ może się
 ## Funkcje
 Oczywistym sposobem na zmniejszenie ilości powtórzeń jest umieszczanie bloku kodu w ciele funkcji, która może zostać użyta wielokrotnie w wielu miejscach aplikacji. Należy także wziąć pod uwagę czy istnieje możliwość i zachodzi sens szukania rozwiązania generalnego poprzez funkcję z parametrami wejściowymi.
 
+{% highlight kotlin %}
+class RegisterView {
+
+    fun register() {
+        //get inputs from view
+        val input = "Password123" //mock
+        val reinput = "Password123"
+        val email = "example@androidcode.pl"
+		
+        if(arePasswordsValid(input, reinput) && isEmailValid(email)) {
+            //make register call
+        }
+        else {
+            //show validation error
+        }
+    }
+
+    fun arePasswordsValid(password: String, repassword: String): Boolean {
+        val pattern = Pattern.compile("^(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9]).{6,}$")
+        val matcher = pattern.matcher(password)
+        return matcher.matches() && password == repassword
+
+    }
+
+    fun isEmailValid(email: String): Boolean {
+        val pattern = Pattern.compile("^.+@.+\\..+$")
+        val matcher = pattern.matcher(email)
+        return matcher.matches()
+    }
+	
+    //some body
+}
+
+class ChangePasswordView {
+
+    fun changePassword() {
+        //get inputs from view
+        val input = "Password123" //mock
+        val reinput = "Password123"
+		
+        if(isPasswordValid(input) && input == reinput) {
+            //make register call
+        }
+        else {
+            //show validation error
+        }
+    }
+    
+    fun isPasswordValid(password: String): Boolean {
+        val pattern = Pattern.compile("^(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9]).{6,}$")
+        val matcher = pattern.matcher(password)
+        return matcher.matches()
+    }
+	
+    //some body
+}
+{% endhighlight %}
+
+Walidacja hasła zachodzi w ten sam sposób w conajmniej dwóch miejscach: `RegisterView`, `ChangePasswordView`. Ponadto widok rejestracji sprawdza poprawność wpisanego adresu email. Można przypuszczać, że istnieje spora szansa na ponowne wykorzystanie metod walidacyjnych w innych miejscach aplikacji. W związku z tym warto przenieść metody walidacyjne do jednej klasy pomocniczej `Validator` dodatkowo zachowując ich spójność w całym kodzie.
+
+{% highlight kotlin %}
+class ResetPasswordView {
+
+    fun register() {
+        //get inputs from view
+        val input = "Password123" //mock
+        val reinput = "Password123"
+        val email = "example@androidcode.pl"
+        
+        if(Validator.arePasswordsValid(input, reinput) && Validator.isEmailValid(email)) {
+            //make register call
+        }
+        else {
+            //show validation error
+        }
+    }
+    
+    //some body
+}
+
+class ChangePasswordView {
+
+    fun changePassword() {
+        //get inputs from view
+        val input = "Password123" //mock
+        val reinput = "Password123"
+		
+        if(Validator.arePasswordsValid(input, reinput)) {
+            //make register call
+        }
+        else {
+            //show validation error
+        }
+    }
+	
+    //some body
+}
+
+object Validator {
+
+    fun isPasswordValid(password: String): Boolean {
+        val pattern = Pattern.compile("^(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9]).{6,}$")
+        val matcher = pattern.matcher(password)
+        return matcher.matches()
+    }
+
+    fun arePasswordsValid(password: String, repassword: String): Boolean {
+        return isPasswordValid(password) && password == repassword
+    }
+
+    fun isEmailValid(email: String): Boolean {
+        val pattern = Pattern.compile("^.+@.+\\..+$")
+        val matcher = pattern.matcher(email)
+        return matcher.matches()
+    }
+}
+{% endhighlight %}
+
 ## Stałe
 Warto rozważyć zastosowanie zarówno stałych lokalnych jak i globalnych, które poza redukcją powielania zwiększają czytelność kodu w wyniku zastępienia niekoniecznie zrozumiałych nazw zmiennych.
 
+{% highlight kotlin %}
+class DateUtils {
+
+    fun getDaysInMiliseconds(miliseconds: Long): Long {
+        return miliseconds / 1000 * 60 * 60 * 24
+    }
+    
+    fun getMilisecondsInDays(days: Long): Long { 
+        return days * 1000 * 60 * 60 * 24
+    }
+}
+{% endhighlight %}
+
+Metody klasy pomocnicznej `DateUtils` wykorzystują w swoich obliczeniach mnożnik reprezentujący ilość milisekund w dniu. Aby zaoszczędzić powielenia kodu i uniknąć pomyłki należy stworzyć stałą `MILISECONDS_IN_DAYS` i wykorzystać ją w metodach.
+
+{% highlight kotlin %}
+class DateUtils {
+    
+    companion object {
+        const val MILISECONDS_IN_DAYS: Long = 1000 * 60 * 60 * 24
+    }
+
+    fun getDaysInMiliseconds(miliseconds: Long): Long {
+        return miliseconds / MILISECONDS_IN_DAYS
+    }
+
+    fun getMilisecondsInDays(days: Long): Long {
+        return days * MILISECONDS_IN_DAYS
+    }
+}
+{% endhighlight %}
+
 ## Typy
 Wykonanie żądanej operacji może się wiązać z przekazaniem argumentów i zwróceniem wyniku, które mogą się składać z kilku obiektów. W takiej sytuacji zasadnym może być stworzenie nowego typu danych zawierającego obiekty typów argumentów wejściowych lub wyjściowych.
 
-## Polimorfizm
-Polimorfizm umożliwia spójne wykorzystanie elementów na kilka różnych sposobów niezależnie od ich typów za pomocą jednego wspólnego interfejsu. Eliminuje instrukcje warunkowe zależne od typu i redukuje powtarzający się kod za pomocą m.in. mechanizmu dziedziczenia.
+{% highlight kotlin %}
+class PlayerManager {
+
+	fun changeNick(id: Long, newNick: String) {
+        //put newNick to database or send to server
+    }
+
+    fun getLevel(points: Int): String {
+        return when(points) {
+            in 0..99 -> "BEGINNER"
+            in 100..300 -> "JUNIOR"
+            in 300..599 -> "ADVANCED"
+            else -> "MASTER"
+        }
+    }
+	
+	fun increasePoints(id: Long, points: Int, percent: Int) {
+        val newPoints = points + points * percent
+        updateLevel(id, newPoints)
+        //put newPoints to database or send to server using id
+    }
+	
+	private fun updateLevel(id: Long, points: Int) {
+        val newLevel = getLevel(points)
+        //put newLevel to database or send to server using id
+    }
+}
+{% endhighlight %}
+
+Metody klasy `PlayerManager` operują na wielu parametrach różnego typu w celu zastosowania operacji na danych zawodnika. Wymienione argumenty są ze sobą logicznie powiązane i mogą składać się na pola klasy `Player`. Wówczas część odpowiedzialności z klasy `PlayerManager` mogłaby zostać przeniesiona do klasy `Player`.
+
+{% highlight kotlin %}
+class PlayerManager {
+
+    fun changeNick(player: Player, newNick: String) {
+        player.nick = newNick
+        //put player to database or send to server
+    }
+    
+    fun increasePoints(player: Player, percent: Int) {
+        player.increasePointsByPercent(percent)
+        //put player to database or send to server
+    }
+}
+
+data class Player(val id: Long, var nick: String, var points: Int, var level: Level) {
+
+    init {
+        updateLevel()
+    }
+
+    fun increasePointsByPercent(percent: Int) {
+        points += points * percent
+        updateLevel()
+    }
+
+    fun updateLevel() {
+        level = when(points) {
+            in 0..99 -> Level.BEGINNER
+            in 100..300 -> Level.JUNIOR
+            in 300..599 -> Level.ADVANCED
+            else -> Level.MASTER
+        }
+    }
+
+    enum class Level(value: String) {
+        BEGINNER("BEGINNER"),
+        JUNIOR("JUNIOR"),
+        ADVANCED("ADVANCED"),
+        MASTER("MASTER")
+    }
+}
+{% endhighlight %}
+
+## Polimorfizm i dziedziczenie
+Polimorfizm umożliwia spójne wykorzystanie elementów na kilka różnych sposobów niezależnie od ich typów za pomocą jednego wspólnego interfejsu. Eliminuje instrukcje warunkowe zależne od typu i redukuje powtarzający się kod. Mechanizm dziedziczenia pozwala na wykorzystanie współdzielonego kodu typu bazowego przez jego podtypy.
+
+{% highlight kotlin %}
+class Book(val index: Long, val title: String, val description: String, val year: Int,
+                val author: String, val topics: List<String>) {
+
+    fun getSummary(): String {
+        return "$title ($year) \n $description"
+    }
+
+    fun print() {
+        //get Book from database by index and print to file
+    }
+}
+
+class Article(val index: Long, val title: String, val description: String, val year: Int,
+              val author: String, val pages: Int) {
+
+    fun getSummary(): String {
+        return "$title ($year) \n $description"
+    }
+
+    fun print() {
+        //get Article from database by index and print to file
+    }
+}
+
+class Film(val index: Long, val title: String, val description: String, val year: Int,
+           val director: String, val actors: List<Actor>, val duration: Int) {
+
+    fun getSummary(): String {
+        return "$title ($year) \n $description"
+    }
+}
+
+class Music(val index: Long, val title: String, val description: String, val year: Int,
+            val band: String, val duration: Int) {
+
+    fun getSummary(): String {
+        return "$title ($year) \n $description"
+    }
+}
+{% endhighlight %}
+
+Klasy `Book`, `Article`, `Film`, `Music` posiadają właściwości i cechy wspólne, które powinny zostać wyabstrachowane do typu wspólnego `Item`. Ponadto klient wykorzystujący te obiekty jest zmuszony do sprawdzania typów i rzutowania, aby dokonać wydruku elementów papierowych. Zachowanie opisujące możliwość wydruku może zostać przeniesione do interfejsu `Printable` i jego implementacji w wybranych klasach.
+
+{% highlight kotlin %}
+class Book(index: Long, title: String, description: String, year: Int,
+                val author: String, val topics: List<String>) : Item(index, title, description, year), Printable {
+
+    override fun print() {
+        //get Book from database by index and print to file
+    }
+}
+
+class Article(index: Long, title: String, description: String, year: Int,
+              val author: String, val pages: Int) : Item(index, title, description, year), Printable {
+
+    override fun print() {
+        //get Article from database by index and print to file
+    }
+}
+
+abstract class Item (val index: Long, val title: String, val description: String, val year: Int) {
+
+    fun getSummary(): String {
+        return "$title ($year) \n $description"
+    }
+}
+
+class Film(index: Long, title: String, description: String, year: Int,
+           val director: String, val actors: List<Actor>, val duration: Int) : Item(index, title, description, year)
+		   
+class Music(index: Long, title: String, description: String, year: Int,
+            val band: String, val duration: Int) : Item(index, title, description, year)
+
+interface Printable {
+
+    fun print()
+}
+{% endhighlight %}
 
 ## Moduły
-Dzielenie kodu na moduły umożliwia nie tylko wyróżnienie części logicznych i funkcjonalnych aplikacji, ale może ułatwić ponowne użycie danej funkcjonalności w innym projekcie. W szczególności są to zewnętrzne biblioteki i wtyczki.
+Dzielenie kodu na moduły umożliwia nie tylko wyróżnienie części logicznych i funkcjonalnych aplikacji, ale może ułatwić ponowne użycie danej funkcjonalności w innym projekcie. W szczególności są to zewnętrzne biblioteki i wtyczki.
+
+{% highlight kotlin %}
+class Calculator {
+
+    fun sqrt(value: Double): Double {
+        return value * value
+    }
+
+    fun doubleSqrt(value: Double): Double {
+        return 2 * sqrt(value)
+    }
+
+    fun pow(value: Double, exponent: Int): Double {
+        return if(exponent == 0)
+            1.0
+        else {
+            var result = value
+            for(i in exponent downTo 1) {
+                result *= value
+            }
+            result
+        }
+    }
+    
+    fun doublePow(value: Double, exponent: Int): Double {
+        return 2 * pow(value, exponent)
+    }
+}
+{% endhighlight %}
+
+Klasa `Calculator` dostarcza zbiór metod wykonujących obliczenia matematyczne. Część definicji zawiera się jednak w pakiecie matematycznym `Math` w związku z czym mogą one zostać wykorzystane zamiast autorskiej implementacji.
+
+{% highlight kotlin %}
+class Calculator {
+
+    //use Math module instead of own functions
+    
+    fun doubleSqrt(value: Double): Double {
+        return 2 * Math.sqrt(value)
+    }
+
+    fun doublePow(value: Double, exponent: Int): Double {
+        return 2 * Math.pow(value, exponent.toDouble())
+    }
+}
+{% endhighlight %}
