refactored some patterns: Command, Decorator, Facade, Visitor

Author: DmitryTsyvtsyn

src/main/kotlin/design_patterns/Command.kt

@@ -2,9 +2,7 @@ package design_patterns
 
 /**
  *
- * pattern: Command
- *
- * description: it's a behavioral pattern that allows you to wrap requests or simple operations in separate objects.
+ * Command is a behavioral pattern that allows you to wrap requests or simple operations in separate objects
  *
  * P.S. Kotlin variant of this pattern is shown in tests
  *
@@ -31,3 +29,14 @@ class MultiCommand(private val coefficient: Int) : ArithmeticCommand {
         return number * coefficient
     }
 }
+
+// we can also create the command that accepts others
+class MacroCommand(private vararg val commands: ArithmeticCommand) : ArithmeticCommand {
+    override fun execute(number: Int): Int {
+        var result = number
+        commands.forEach {
+            result = it.execute(result)
+        }
+        return result
+    }
+}

src/main/kotlin/design_patterns/Decorator.kt

@@ -2,11 +2,10 @@ package design_patterns
 
 /**
  *
- * pattern: Decorator
+ * Decorator is a structural design pattern that adds new functionality to an object:
  *
- * using: used to add additional functionality to an object
+ * classes implement a common interface and to extend the functionality of the previous object,
  *
- * description: classes implement a common interface and to extend the functionality of the previous object,
  * the old object is passed through the constructor
  *
  */
@@ -15,45 +14,35 @@ interface MyPrinter {
     fun printedText() : String
 }
 
-/**
- * just returns "Hello"
- */
+// just returns "Hello"
 class HelloPrinter : MyPrinter {
     override fun printedText() : String {
         return "Hello"
     }
 }
 
-/**
- * adds a comma to the previous value of the printedText() function
- */
+// adds a comma to the previous value of the printedText() function
 class CommaPrinter(private val printer: MyPrinter) : MyPrinter {
     override fun printedText() : String {
         return "${printer.printedText()},"
     }
 }
 
-/**
- * adds a space to the previous value of the printedText() function
- */
+// adds a space to the previous value of the printedText() function
 class SpacePrinter(private val printer: MyPrinter) : MyPrinter {
     override fun printedText() : String {
         return "${printer.printedText()} "
     }
 }
 
-/**
- * adds the word "World" to the previous value of the printedText() function
- */
+// adds the word "World" to the previous value of the printedText() function
 class WorldPrinter(private val printer: MyPrinter) : MyPrinter {
     override fun printedText() : String {
         return "${printer.printedText()}World"
     }
 }
 
-/**
- * adds an exclamation mark to the previous value of the printedText() function
- */
+// adds an exclamation mark to the previous value of the printedText() function
 class ExclamationPrinter(private val printer: MyPrinter) : MyPrinter {
     override fun printedText() : String {
         return "${printer.printedText()}!"

src/main/kotlin/design_patterns/Facade.kt

@@ -2,51 +2,101 @@ package design_patterns
 
 /**
  *
- * pattern: Facade
+ * Facade is a structural design pattern that simplifies the interface to a group of interfaces
  *
- * using: used to simplify access to an object with a complex implementation
- *
- * description: a complex object contains several dependencies within itself, which it combines with each other
+ * with a more complex implementation
  *
  */
 
+data class GoodsEntity(
+    private val id: Long,
+    private val name: String,
+    private val description: String,
+    private val price: Double
+)
 
-/**
- * imitation of local data storage (database)
- */
-class LocalDataSource {
-
-    private val data = mutableListOf<String>()
+class GoodsDatabase {
+    private val cachedGoods = mutableListOf<GoodsEntity>()
 
-    fun save(data: List<String>) {
-        this.data.addAll(data)
+    fun save(goods: List<GoodsEntity>) {
+        cachedGoods.addAll(goods)
     }
 
-    fun read() = data
-    fun isEmpty() = data.isEmpty()
+    fun read() = cachedGoods
+}
+
+class GoodsNetworkService {
+
+    fun fetch() = listOf(
+        GoodsEntity(
+            id = 1,
+            name = "Head First Design Patterns: Building Extensible and Maintainable Object-Oriented Software 2nd Edition",
+            description = "You know you don't want to reinvent the wheel, so you look to Design Patterns: the lessons learned by those who've faced the same software design problems.",
+            price = 41.94
+        )
+    )
 
 }
 
-/**
- * network request simulation
- */
-class NetworkDataSource {
-    fun get() = listOf(
-        "Harry Potter",
-        "Ronald Weasley",
-        "Hermione Granger"
+data class CategoryEntity(
+    private val id: Long,
+    private val name: String
+)
+
+class CategoryDatabase {
+    private val cachedCategories = mutableListOf<CategoryEntity>()
+
+    fun save(goods: List<CategoryEntity>) {
+        cachedCategories.addAll(goods)
+    }
+
+    fun read() = cachedCategories
+}
+
+class CategoryNetworkService {
+
+    fun fetch() = listOf(
+        CategoryEntity(
+            id = 1,
+            name = "Books"
+        )
     )
+
 }
 
-class Repository(private val localSource: LocalDataSource, private val networkSource: NetworkDataSource) {
+data class GoodsResult(
+    val goods: List<GoodsEntity>,
+    val categories: List<CategoryEntity>
+)
+
+// we have a group of interfaces (databases and network services)
+class GoodsRepository(
+    private val goodsDatabase: GoodsDatabase,
+    private val goodsNetworkService: GoodsNetworkService,
+    private val categoryDatabase: CategoryDatabase,
+    private val categoryNetworkService: CategoryNetworkService
+) {
 
-    fun fetch() : List<String> {
-        // I omitted error handling for simplicity
-        if (localSource.isEmpty()) {
-            val data = networkSource.get()
-            localSource.save(data)
+    // we need a simpler interface
+    fun goodsAndCategories() : GoodsResult {
+        val goods = goodsDatabase.read().toMutableList()
+        if (goods.isEmpty()) {
+            val networkGoods = goodsNetworkService.fetch()
+            goodsDatabase.save(networkGoods)
+            goods.addAll(networkGoods)
         }
-        return localSource.read()
+
+        val categories = categoryDatabase.read().toMutableList()
+        if (categories.isEmpty()) {
+            val networkCategories = categoryNetworkService.fetch()
+            categoryDatabase.save(networkCategories)
+            categories.addAll(networkCategories)
+        }
+
+        return GoodsResult(
+            goods = goods,
+            categories = categories
+        )
     }
 
 }

src/main/kotlin/design_patterns/Visitor.kt

@@ -2,9 +2,8 @@ package design_patterns
 
 /**
  *
- * pattern: Visitor
+ * Visitor is a behavioral design pattern that allows you to add a new operation
  *
- * description: it's a behavioral pattern that allows you to add a new operation
  * to an entire class hierarchy without changing the code of these classes.
  *
  */

src/test/kotlin/design_patterns/CommandTest.kt

@@ -6,7 +6,7 @@ import org.junit.Assert.assertEquals
 internal class CommandTest {
 
     @Test
-    fun test_1() {
+    fun `test 1`() {
         val commands = listOf(
             AddCommand(10),
             AddCommand(20),
@@ -23,7 +23,7 @@ internal class CommandTest {
     }
 
     @Test
-    fun test_2() {
+    fun `test 2`() {
         val commands = listOf(
             MultiCommand(2),
             MultiCommand(2),
@@ -42,7 +42,7 @@ internal class CommandTest {
     }
 
     @Test
-    fun test_3() {
+    fun `test 3`() {
         val commands = listOf(
             AddCommand(-1),
             MinusCommand(1000),
@@ -58,7 +58,18 @@ internal class CommandTest {
     }
 
     @Test
-    fun test_kotlin_variant() {
+    fun `test MacroCommand`() {
+        val command = MacroCommand(
+            MultiCommand(2),
+            AddCommand(10),
+            MinusCommand(100)
+        )
+
+        assertEquals(-70, command.execute(10))
+    }
+
+    @Test
+    fun `test Kotlin variant`() {
         val commands: List<(Int) -> Int> = listOf(
             { actual: Int -> actual + 49 },
             { actual: Int -> actual - 20 },

src/test/kotlin/design_patterns/FacadeTest.kt

@@ -7,9 +7,30 @@ internal class FacadeTest {
 
     @Test
     fun test() {
-        val facade = Repository(LocalDataSource(), NetworkDataSource())
-        val data = facade.fetch()
-        assertEquals(listOf("Harry Potter", "Ronald Weasley", "Hermione Granger"), data)
+        val goodsRepository = GoodsRepository(
+            GoodsDatabase(),
+            GoodsNetworkService(),
+            CategoryDatabase(),
+            CategoryNetworkService()
+        )
+
+        val actual = goodsRepository.goodsAndCategories()
+
+        assertEquals(
+            GoodsResult(
+                goods = listOf(GoodsEntity(
+                    id = 1,
+                    name = "Head First Design Patterns: Building Extensible and Maintainable Object-Oriented Software 2nd Edition",
+                    description = "You know you don't want to reinvent the wheel, so you look to Design Patterns: the lessons learned by those who've faced the same software design problems.",
+                    price = 41.94
+                )),
+                categories = listOf(CategoryEntity(
+                    id = 1,
+                    name = "Books"
+                ))
+            ),
+            actual
+        )
     }
 
 }