⭐ feat: 0.2.0

Author: devngho

README.md

@@ -6,6 +6,14 @@ kmarkdown is a **well\-tested** and **pure\-Kotlin** Markdown library\.
 
 This README\.MD was generated using kmarkdown\. [Check it out\!](src/jvmTest/kotlin/io/github/devngho/kmarkdown/Readme.kt)
 
+### Changelog
+
+- 0\.2\.0
+    - How to add elements in MarkdownDSL is changed\.
+    - TextStyle is just a MarkdownElement now\.
+- 0\.1\.0
+    - Initial release
+
 ### Installation
 
 ```kts
@@ -34,11 +42,11 @@ A paragraph represents multiple markdown elements, such as code blocks or list,
 
 ```kotlin
 // in markdown document
-paragraph {
-    block {
++paragraph {
+    +block {
         +("This is a paragraph.")
     }
-    block {
+    +block {
         +("It can contain multiple blocks.")
     }
 }
@@ -60,33 +68,29 @@ A block can contain multiple inline markdown elements like text, link\.
 
 ```kotlin
 // in markdown document
-block {
++block {
     +("This is a block. ")
     +("It can contain multiple markdown elements.")
 
     // or you can use '_' infix function
     // to concatenate markdown elements with a space
 
-    +("This is another way to create a block."() _ "using the '_' infix function."())
+    +(text("This is another way to create a block.") _ text("using the '_' infix function."))
 
     // + operator can concatenate markdown elements without space
 
-    +("+ operator can concatenate "() + "markdown elements without space.")
+    +(text("+ operator can concatenate ") + text("markdown elements without space."))
 
     // or you can use list of markdown elements
 
-    +listOf("You can also use a list of markdown elements."(), "to create a block.")
+    +listOf(text("You can also use a list of markdown elements."), text("to create a block."))
 }
 ```
 
 Output:
 
 This is a block\. It can contain multiple markdown elements\.This is another way to create a block\. using the '\_' infix function\.\+ operator can concatenate markdown elements without space\.You can also use a list of markdown elements\. to create a block\.
 
-> **Why did you append \(\) to the text?**
->
-> Because the text is a markdown element, and the function expects a markdown element\. You can add styles to the text by appending styles to the text\.
-
 #### Heading
 
 To create a heading, you can use the `heading` function\.
@@ -95,8 +99,8 @@ The `heading` function takes a level and text as parameters\.
 
 ```kotlin
 // in markdown document
-heading(2, "Hello, World!") {
-    block {
++heading(2, "Hello, World!") {
+    +block {
         +("This is a heading.")
     }
 }
@@ -116,7 +120,7 @@ The `link` function takes a text and url as parameters\.
 
 ```kotlin
 // in markdown document
-link("This is a link", "https://example.com")
++link("This is a link", "https://example.com")
 ```
 
 Output:
@@ -131,11 +135,11 @@ The `list` function takes a list style as a parameter\.
 
 ```kotlin
 // in markdown document
-list(List.ListStyle.ORDERED) {
++list(List.ListStyle.ORDERED) {
     item {
         +"This is a list item."
     }
-    list(List.ListStyle.UNORDERED) {
+    list(List.ListStyle.ORDERED) {
         item {
             +"This is a nested list item."
         }
@@ -146,7 +150,7 @@ list(List.ListStyle.ORDERED) {
 Output:
 
 1. This is a list item\.
-- This is a nested list item\.
+1. This is a nested list item\.
 
 #### Blockquote
 
@@ -156,8 +160,8 @@ The `blockquote` function takes a block as a parameter\.
 
 ```kotlin
 // in markdown document
-blockquote {
-    block {
++blockquote {
+    +block {
         +("This is a blockquote.")
     }
 }
@@ -175,8 +179,8 @@ The `codeblock` function takes a code block and language \(optional\) as paramet
 
 ```kotlin
 // in markdown document
-codeblock("println(\"Hello, World!\")", "kotlin")
-codeblock("Language is optional.")
++codeblock("println(\"Hello, World!\")", "kotlin")
++codeblock("Language is optional.")
 ```
 
 Output:
@@ -195,7 +199,7 @@ The `inlineCodeBlock` function takes a code block as a parameter\.
 
 ```kotlin
 // in markdown document
-inlineCodeBlock("println(\"Hello, World!\")")
++inlineCodeBlock("println(\"Hello, World!\")")
 ```
 
 Output:
@@ -214,7 +218,7 @@ The `raw` function takes a text as a parameter\.
 
 ```kotlin
 // in markdown document
-raw("This is a raw element.")
++raw("This is a raw element.")
 ```
 
 Output:

README_ko.md

@@ -1,11 +1,19 @@
-[English](README.md)  \| 한국어
+[English](README.md)  \|  한국어
 
 ## kmarkdown
 
-kmarkdown은 **잘 테스트된**, **순수한 Kotlin** Markdown 라이브러리입니다\.
+kmarkdown은 **잘 테스트된**, **순수한 코틀린** 마크다운 라이브러리입니다\.
 
 이 README\.md는 kmarkdown으로 쓰여졌어요\. [확인해보세요\!](src/jvmTest/kotlin/io/github/devngho/kmarkdown/Readme.kt)
 
+### 변경 내역
+
+- 0\.2\.0
+    - MarkdownDSL에 요소를 추가하는 방법이 변경되었습니다\.
+    - TextStyle는 이제 일반 MarkdownElement입니다\.
+- 0\.1\.0
+    - 첫 릴리즈
+
 ### 설치
 
 ```kts
@@ -30,11 +38,11 @@ val document = markdown(GFMFlavor) {
 
 ```kotlin
 // 마크다운 문서 안에서 사용하세요
-paragraph {
-    block {
++paragraph {
+    +block {
         +("이건 문단입니다.")
     }
-    block {
+    +block {
         +("여러 블럭을 포함할 수 있습니다.")
     }
 }
@@ -56,40 +64,36 @@ paragraph {
 
 ```kotlin
 // 마크다운 문서 안에서 사용하세요
-block {
++block {
     +("이건 블럭입니다. ")
     +("여러 마크다운 요소를 포함할 수 있습니다.")
 
     // 또는 '_' infix 함수를 사용해 공백으로 마크다운 요소를 연결할 수 있습니다.
 
-    +("_ infix 함수를 사용해"() _ "이렇게 블럭을 만들 수도 있습니다."())
+    +(text("_ infix 함수를 사용해") _ text("이렇게 블럭을 만들 수도 있습니다."))
 
     // + 연산자는 공백 없이 마크다운 요소를 연결할 수 있습니다.
 
-    +("+ 연산자를 사용해 "() + "이렇게 블럭을 만들 수도 있습니다.")
+    +(text("+ 연산자를 사용해 ") + text("이렇게 블럭을 만들 수도 있습니다."))
 
     // 또는 마크다운 요소의 리스트를 사용할 수도 있습니다.
 
-    +listOf("리스트를 사용해"(), "블럭을 만들 수도 있습니다."())
+    +listOf(text("리스트를 사용해"), text("블럭을 만들 수도 있습니다."))
 }
 ```
 
 출력:
 
-이건 블럭입니다\. 여러 마크다운 요소를 포함할 수 있습니다\.\+ 연산자를 사용해 이렇게 블럭을 만들 수도 있습니다\.이렇게 블럭을 만들 수도 있습니다\. 사용해리스트를 사용해 블럭을 만들 수도 있습니다\.
-
-> **텍스트 뒤에 왜 \(\)를 붙였나요?**
->
-> 마크다운 `Text`로 변환하기 위함입니다\. \(\) 안에 `Bold`와 같은 스타일을 추가할 수 있습니다\.
+이건 블럭입니다\. 여러 마크다운 요소를 포함할 수 있습니다\.\_ infix 함수를 사용해 이렇게 블럭을 만들 수도 있습니다\.\+ 연산자를 사용해 이렇게 블럭을 만들 수도 있습니다\.리스트를 사용해 블럭을 만들 수도 있습니다\.
 
 #### 헤딩
 
 헤딩을 만드려면 `heading` 함수를 사용하세요\.
 
 ```kotlin
 // 마크다운 문서 안에서 사용하세요
-heading(2, "Hello, World!") {
-    block {
++heading(2, "Hello, World!") {
+    +block {
         +("이건 헤딩입니다.")
     }
 }
@@ -107,7 +111,7 @@ heading(2, "Hello, World!") {
 
 ```kotlin
 // 마크다운 문서 안에서 사용하세요
-link("이건 링크입니다.", "https://example.com")
++link("이건 링크입니다.", "https://example.com")
 ```
 
 출력:
@@ -120,7 +124,7 @@ link("이건 링크입니다.", "https://example.com")
 
 ```kotlin
 // 마크다운 문서 안에서 사용하세요
-list(List.ListStyle.ORDERED) {
++list(List.ListStyle.ORDERED) {
     item {
         +"리스트 아이템입니다."
     }
@@ -143,8 +147,8 @@ list(List.ListStyle.ORDERED) {
 
 ```kotlin
 // 마크다운 문서 안에서 사용하세요
-blockquote {
-    block {
++blockquote {
+    +block {
         +("이건 인용구입니다.")
     }
 }
@@ -160,8 +164,8 @@ blockquote {
 
 ```kotlin
 // 마크다운 문서 안에서 사용하세요
-codeblock("println(\"Hello, World!\")", "kotlin")
-codeblock("언어 옵션은 선택입니다.")
++codeblock("println(\"Hello, World!\")", "kotlin")
++codeblock("언어 옵션은 선택입니다.")
 ```
 
 출력:
@@ -178,7 +182,7 @@ println("Hello, World!")
 
 ```kotlin
 // 마크다운 문서 안에서 사용하세요
-inlineCodeBlock("println(\"Hello, World!\")")
++inlineCodeBlock("println(\"Hello, World!\")")
 ```
 
 출력:
@@ -187,15 +191,15 @@ inlineCodeBlock("println(\"Hello, World!\")")
 
 #### Raw
 
-> **Raw 요소를 사용하는 것은 권장되지 않습니다\.**
+> **Raw 요소를 사용하는 것은 권장하지 않습니다\.**
 >
 > 대신에 커스텀 `Flavor`를 만드는 것을 추천합니다\.
 
 Raw 요소를 만드려면 `raw` 함수를 사용하세요\.
 
 ```kotlin
 // 마크다운 문서 안에서 사용하세요
-raw("이건 Raw 요소입니다.")
++raw("이건 Raw 요소입니다.")
 ```
 
 출력:

build.gradle.kts

@@ -8,7 +8,7 @@ plugins {
 }
 
 group = "io.github.devngho"
-version = "0.1.0"
+version = "0.2.0"
 
 repositories {
     mavenCentral()
@@ -113,6 +113,7 @@ kotlin {
             implementation("io.kotest:kotest-runner-junit5:$kotestVersion")
             implementation(kotlin("test-common"))
             implementation(kotlin("test-annotations-common"))
+            implementation(kotlin("reflect"))
         }
 
         applyDefaultHierarchyTemplate()

src/commonMain/kotlin/io/github/devngho/kmarkdown/builder/MarkdownDSL.kt

@@ -13,6 +13,14 @@ class MarkdownDSL internal constructor(val flavor: Flavor) {
         elements.add(element)
     }
 
+    operator fun MarkdownElement.unaryPlus() {
+        elements.add(this)
+    }
+
+    operator fun List<MarkdownElement>.unaryPlus() {
+        elements.addAll(this)
+    }
+
     fun build(): String = flavor.build(elements.map { it.convertTo(flavor) })
 
     companion object {

src/commonMain/kotlin/io/github/devngho/kmarkdown/flavor/Flavor.kt

@@ -14,7 +14,6 @@ interface Flavor {
     }
 
     val elements: Map<String, MarkdownElementDescriptor<*>>
-    val staticElements: Map<String, MarkdownElementDescriptor<*>>
 
     fun build(elements: List<MarkdownElement>): String
 }

src/commonMain/kotlin/io/github/devngho/kmarkdown/flavor/common/Block.kt

@@ -45,20 +45,13 @@ data class Block(val children: kotlin.collections.List<MarkdownElement>): Markdo
         /** Combines two elements with a space between them. */
         infix fun String.`_`(element: MarkdownElement) = Block(listOf(Text(this), Text(" "), element))
 
-        fun String.styled(vararg style: Text.TextStyle) = Text(this, style.toMutableList())
-
-        operator fun String.invoke(vararg style: Text.TextStyle) = Text(this, style.toMutableList())
-
-        fun build(): kotlin.collections.List<MarkdownElement> = elements.map { it.convertTo<MarkdownElement>(flavor) }
+        fun build(): kotlin.collections.List<MarkdownElement> = elements.map { it.convertTo(flavor) }
     }
 
     override fun encode(): String = children.joinToString("") { it.encode() }
 
     companion object: MarkdownElementDescriptor<Block> {
-        fun MarkdownDSL.block(block: BlockDSL.() -> Unit) {
-            val element = Block(BlockDSL(this.flavor).apply(block).build())
-            add(element)
-        }
+        fun MarkdownDSL.block(block: BlockDSL.() -> Unit) = Block(BlockDSL(this.flavor).apply(block).build())
 
         override val id: String = "block"
         override val flavor: Flavor = CommonFlavor

src/commonMain/kotlin/io/github/devngho/kmarkdown/flavor/common/Blockquote.kt

@@ -14,11 +14,7 @@ data class Blockquote(val children: Paragraph) : MarkdownElement {
     override fun encode(): String = children.encode().prependIndent("> ")
 
     companion object: MarkdownElementDescriptor<Blockquote> {
-        fun MarkdownDSL.blockquote(block: MarkdownDSL.() -> Unit) {
-            val element = Blockquote(Paragraph(MarkdownDSL(this.flavor).apply(block).elements))
-
-            add(element)
-        }
+        fun MarkdownDSL.blockquote(block: MarkdownDSL.() -> Unit) = Blockquote(Paragraph(MarkdownDSL(this.flavor).apply(block).elements))
 
         override val id: String = "blockquote"
         override val flavor: Flavor = CommonFlavor