Fix issue 281 (#303)

* Fix issue 281

* Updated documentation

Author: stefankoppier

compiler-plugin/src/main/kotlin/tech/mappie/ir/generation/IrMappieGeneratedClass.kt

@@ -109,9 +109,15 @@ class IrMappieGeneratedClass(override var name: Name) : IrClass() {
 
     companion object {
         fun named(source: IrType, target: IrType): IrClass {
-            val source = source.makeNotNull().dumpKotlinLike()
-            val target  = target.makeNotNull().dumpKotlinLike()
+            val source = source.identifier()
+            val target  = target.identifier()
             return IrMappieGeneratedClass(identifier(source + "To" + target + "Mapper"))
         }
+
+        private fun IrType.identifier() =
+            makeNotNull()
+                .dumpKotlinLike()
+                .replace("<", "")
+                .replace(">", "")
     }
 }

compiler-plugin/src/test/kotlin/tech/mappie/testing/sets/MapLinkedHashSetTest.kt

@@ -0,0 +1,63 @@
+package tech.mappie.testing.sets
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+import tech.mappie.testing.MappieTestCase
+
+class MapLinkedHashSetTest : MappieTestCase() {
+
+    data class Input(val value: LinkedHashSet<InnerInput>)
+    data class InnerInput(val value: String)
+
+    data class Output(val value: LinkedHashSet<InnerOutput>)
+    data class InnerOutput(val value: String)
+
+    @Test
+    fun `map LinkedHashSet implicit succeed`() {
+        compile {
+            file("Test.kt",
+                """
+                import tech.mappie.api.ObjectMappie
+                import tech.mappie.testing.sets.MapLinkedHashSetTest.*
+
+                class Mapper : ObjectMappie<Input, Output>()
+                """
+            )
+        } satisfies {
+            isOk()
+            hasNoWarningsOrErrors()
+
+            val mapper = objectMappie<Input, Output>()
+
+            assertThat(mapper.map(Input(LinkedHashSet(listOf(InnerInput("element"))))))
+                .isEqualTo(Output(LinkedHashSet(emptyList())))
+        }
+    }
+
+    @Test
+    fun `map LinkedHashSet explicit succeed`() {
+        compile {
+            file("Test.kt",
+                """
+                import tech.mappie.api.ObjectMappie
+                import tech.mappie.api.Mappie1
+                import tech.mappie.testing.sets.MapLinkedHashSetTest.*
+
+                class Mapper : ObjectMappie<Input, Output>()
+
+                class LinkedHashSetMapper<T, R>(private val inner: Mappie1<T, R>) : ObjectMappie<LinkedHashSet<T>, LinkedHashSet<R>>() {
+                    override fun map(from: LinkedHashSet<T>) = LinkedHashSet<R>(from.map(inner::map))
+                }
+                """
+            )
+        } satisfies {
+            isOk()
+            hasNoWarningsOrErrors()
+
+            val mapper = objectMappie<Input, Output>()
+
+            assertThat(mapper.map(Input(LinkedHashSet(listOf(InnerInput("element"))))))
+                .isEqualTo(Output(LinkedHashSet(listOf(InnerOutput("element")))))
+        }
+    }
+}

website/src/posts/object-mapping/posts/built-in.md

@@ -13,6 +13,9 @@ can be applied explicitly, or implicitly.
 The types below that are in *cursive* are not available on all platforms. For example, `BigInteger` is only available
 on the JVM platform.
 
+## Collection Mappers
+There is support for mapping any `Iterable` of type `T` to any of `List`, `Set`, `MutableList`, and `MutableSet` of type `R`.
+
 ## Numeric Mappers
 The following integer mappers are built-in
 
@@ -55,6 +58,9 @@ The following UUID mappers are built-in
 |--------|--------|--------|
 | *UUID* | -      | X      |
 
+## The identity Mapper
+The identity mapper named `IdentityMapper` maps any `T` to any `T`.
+
 ## kotlinx-datetime Mappers
 The following kotlinx-datetime mappers can be included via the dependency `tech.mappie.api:module-kotlinx-datetime`.
 

website/src/posts/object-mapping/posts/collections.md

@@ -7,16 +7,24 @@ eleventyNavigation:
   order: 10
 ---
 
-All mappers of Mappie define mapper variants for collections. Specifically, for `List` and `Set`. When we want to map a 
-property of such a type, we do not want to copy the collection itself, but the elements contained in such a type. 
+Mappie has extensive support for collection types. 
 
-Mappie automatically detects if the property is a (nullable) collection, and will automatically select the correct mapping 
-function to be used. 
+An `ObjectMappie` defines the functions `mapList`, `mapSet`, 
+`mapArray` (JVM only), and nullable variants `mapNullableList`, `mapNullableSet` to map collections directly.
 
-We can also explicitly reference a mapper using the getters `forList` and `forSet` defined 
-in each mapper. 
+For example, we can use `mapList` to automatically map a `List`
+```kotlin
+object PersonMapper : ObjectMappie<Person, PersonDto>()
+
+val persons: List<Person> = listOf(Person("Sjon"), Person("Piet"))
+val personDtos: List<PersonDto> = PersonMapper.mapList(persons)
+```
 
-For example, suppose we have the data class `Book` containing a list of `Page`
+Mappie also defines several built-in mappers to map collections, most notable for `List` and `Set`. These built-in 
+mappers are used to automatically map collection types. When defining a mapping manually, these mappers can be 
+referenced explicitly; they are defined in the package `mappie.api.builtin.collections`.
+
+For example, suppose we have the data class `Book` containing a list of `Page`:
 ```kotlin
 data class Book(val pages: List<Page>)
 
@@ -28,19 +36,27 @@ data class BookDto(val pages: List<String>)
 ```
 
 We can define a mapping between `Book` and `BookDto` by defining two mappers: a mapper for `Page` to `String`, which simply
-gets the `text` property, and mapper between `Book` and `BookDto` using the inner `forList` mapper of the `PageMapper`
+gets the `text` property, and a mapper between `Book` and `BookDto` which uses the built-in mapper `IterableToListMapper`:
 ```kotlin
 object PageMapper : ObjectMappie<Page, String>() {
     override fun map(from: Page): String = from.text
 }
 
 object BookMapper : ObjectMappie<Book, BookDto>() {
     override fun map(from: Book): BookDto = mapping {
-        BookDto::pages fromProperty Book::pages via PageMapper.forList
+        BookDto::pages fromProperty Book::pages via IterableToListMapper(PageMapper)
+    }
+}
+```
+Note that in this case `BookMapper` is superfluous and is equivalent to 
+```kotlin
+object BookMapper : ObjectMappie<Book, BookDto>() {
+    override fun map(from: Book): BookDto = mapping {
+        BookDto::pages fromProperty Book::pages
     }
 }
 ```
-Note that `BookMapper` is superfluous and is equivalent to 
+or even 
 ```kotlin
 object BookMapper : ObjectMappie<Book, BookDto>()
 ```