EJBlock moshi parser

Author: xISRAPILx

editorjskit/src/main/java/work/upstarts/editorjskit/models/EJBlock.kt

@@ -2,48 +2,47 @@ package work.upstarts.editorjskit.models
 
 import work.upstarts.editorjskit.models.data.*
 
-abstract class EJBlock(
-    open val type: EJAbstractBlockType,
-    open val data: EJData
-)
+interface EJBlock{
+    val type: EJAbstractBlockType
+    val data: EJData
+}
 
 class EJCustomBlock(
     override val type: EJAbstractBlockType,
     override val data: EJData
-): EJBlock(type, data)
+): EJBlock
 
 data class EJHeaderBlock(
     override val type: EJAbstractBlockType,
     override val data: EJHeaderData
-): EJBlock(type, data)
+): EJBlock
 
 data class EJParagraphBlock(
     override val type: EJAbstractBlockType,
     override val data: EJParagraphData
-): EJBlock(type, data)
+): EJBlock
 
 data class EJListBlock(
     override val type: EJAbstractBlockType,
     override val data: EJListData
-): EJBlock(type, data)
+): EJBlock
 
 data class EJDelimiterBlock(
     override val type: EJAbstractBlockType,
     override val data: EJData
-): EJBlock(type, data)
+): EJBlock
 
 data class EJImageBlock(
     override val type: EJAbstractBlockType,
     override val data: EJImageData
-): EJBlock(type, data)
+): EJBlock
 
 data class EJRawHtmlBlock(
     override val type: EJAbstractBlockType,
     override val data: EJRawHtmlData
-): EJBlock(type, data)
-
+): EJBlock
 
 data class EJTableBlock(
     override val type: EJAbstractBlockType,
     override val data: EJTableData
-): EJBlock(type, data)
+): EJBlock

moshiparser/.gitignore

@@ -0,0 +1 @@
+/build

moshiparser/build.gradle

@@ -0,0 +1,57 @@
+apply plugin: 'com.android.library'
+apply plugin: 'com.novoda.bintray-release'
+apply plugin: 'kotlin-android'
+
+buildscript {
+    repositories {
+        mavenLocal()
+        jcenter()
+    }
+    dependencies {
+        classpath "com.novoda:bintray-release:${versions.novoda_bintray_plugin}"
+    }
+}
+
+android {
+    compileSdkVersion versions.compileSdk
+
+    defaultConfig {
+        minSdkVersion versions.minSdk
+        targetSdkVersion versions.targetSdk
+        versionCode 1
+        versionName "1.0"
+
+        consumerProguardFiles 'consumer-rules.pro'
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+}
+
+dependencies {
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${versions.kotlin}"
+
+    //Moshi
+    implementation("com.squareup.moshi:moshi-kotlin:1.11.0")
+    implementation "com.squareup.moshi:moshi-adapters:1.11.0"
+
+    api project(":editorjskit")
+    testImplementation 'junit:junit:4.13.2'
+}
+
+sourceCompatibility = "1.7"
+targetCompatibility = "1.7"
+
+apply from: rootProject.file("gradle/publish.gradle")
+publish {
+    repoName = 'EditorJSKit-Moshi'
+    artifactId = 'ejkit-moshi'
+}

moshiparser/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest package="work.upstarts.moshiparser" />

moshiparser/src/main/java/work/upstarts/moshiparser/EJAbstractBlockTypeAdapter.kt

@@ -0,0 +1,18 @@
+package work.upstarts.moshiparser
+
+import com.squareup.moshi.FromJson
+import com.squareup.moshi.ToJson
+import work.upstarts.editorjskit.models.EJAbstractBlockType
+import work.upstarts.editorjskit.models.EJBlockType
+
+class EJAbstractBlockTypeAdapter{
+    @FromJson
+    fun fromJson(type: String): EJAbstractBlockType {
+        return EJBlockType.fromString(type)
+    }
+
+    @ToJson
+    fun toJson(type: EJAbstractBlockType): String {
+        return type.jsonName
+    }
+}

moshiparser/src/main/java/work/upstarts/moshiparser/EJBlockAdapter.kt

@@ -0,0 +1,84 @@
+package work.upstarts.moshiparser
+
+import com.squareup.moshi.*
+import work.upstarts.editorjskit.EJKit
+import work.upstarts.editorjskit.models.*
+import work.upstarts.editorjskit.models.data.*
+
+class EJBlockAdapter(
+    private val moshi: Moshi
+) {
+    @FromJson
+    fun fromJson(jsonData: Map<String, Any>): EJBlock? {
+        val type = jsonData["type"].toString()
+        val data = jsonData["data"] ?: throw IllegalStateException("Data cannot be null")
+        try {
+            return when (val ejBlockType = EJBlockType.fromString(type)) {
+                EJBlockType.HEADER -> {
+                    EJHeaderBlock(
+                        ejBlockType,
+                        moshi.adapter(EJHeaderData::class.java).fromJsonValue(data)
+                            ?: throw IllegalStateException("Cannot deserialize ${EJHeaderData::class.java.name}")
+                    )
+                }
+                EJBlockType.PARAGRAPH -> {
+                    EJParagraphBlock(
+                        ejBlockType,
+                        moshi.adapter(EJParagraphData::class.java).fromJsonValue(data)
+                            ?: throw IllegalStateException("Cannot deserialize ${EJParagraphData::class.java.name}")
+                    )
+                }
+                EJBlockType.LIST -> {
+                    EJListBlock(
+                        ejBlockType,
+                        moshi.adapter(EJListData::class.java).fromJsonValue(data)
+                            ?: throw IllegalStateException("Cannot deserialize ${EJListData::class.java.name}")
+                    )
+                }
+                EJBlockType.DELIMITER -> {
+                    EJDelimiterBlock(ejBlockType, EJDelimiterData())
+                }
+                EJBlockType.IMAGE -> {
+                    EJImageBlock(
+                        ejBlockType,
+                        moshi.adapter(EJImageData::class.java).fromJsonValue(data)
+                            ?: throw IllegalStateException("Cannot deserialize ${EJImageData::class.java.name}")
+                    )
+                }
+                EJBlockType.TABLE -> {
+                    EJTableBlock(
+                        ejBlockType,
+                        moshi.adapter(EJTableData::class.java).fromJsonValue(data)
+                            ?: throw IllegalStateException("Cannot deserialize ${EJTableData::class.java.name}")
+                    )
+                }
+                EJBlockType.RAW_HTML -> {
+                    EJRawHtmlBlock(
+                        ejBlockType,
+                        moshi.adapter(EJRawHtmlData::class.java).fromJsonValue(data)
+                            ?: throw IllegalStateException("Cannot deserialize ${EJRawHtmlData::class.java.name}")
+                    )
+                }
+            }
+        } catch (exception: IllegalArgumentException) {
+            EJKit.getCustomBlocks().find { it.type.jsonName == type }?.let {
+                val ejBlockData = moshi.adapter(it.data)
+                    .fromJsonValue(data) ?: throw IllegalStateException("Cannot deserialize ${it.data.name}")
+
+                return EJCustomBlock(
+                    it.type,
+                    ejBlockData
+                )
+            }
+
+            exception.printStackTrace()
+        }
+
+        return null
+    }
+
+    @ToJson
+    fun toJson(block: EJBlock): String? {
+        TODO("Not implemented")
+    }
+}

moshiparser/src/test/java/work/upstarts/moshiparser/EJBlockAdapterTest.kt

@@ -0,0 +1,50 @@
+package work.upstarts.moshiparser
+
+import com.squareup.moshi.Moshi
+import com.squareup.moshi.adapters.PolymorphicJsonAdapterFactory
+import com.squareup.moshi.kotlin.reflect.KotlinJsonAdapterFactory
+import org.hamcrest.CoreMatchers.instanceOf
+import org.junit.Test
+import work.upstarts.editorjskit.models.EJBlock
+import work.upstarts.editorjskit.models.EJBlockType
+import work.upstarts.editorjskit.models.EJParagraphBlock
+
+class EJBlockAdapterTest {
+
+    @Test
+    fun fromJsonWithStandardPolymorphicAdapterSingleParagraph() {
+        val moshi = Moshi.Builder()
+            .add(EJAbstractBlockTypeAdapter())
+            .add(
+                PolymorphicJsonAdapterFactory.of(EJBlock::class.java, "type")
+                    .withSubtype(EJParagraphBlock::class.java, EJBlockType.PARAGRAPH.jsonName)
+            )
+            .add(KotlinJsonAdapterFactory())
+            .build()
+
+        val result = moshi.adapter(EJBlock::class.java)
+            .fromJson(singleParagraph)
+
+        instanceOf<EJParagraphBlock>(EJParagraphBlock::class.java).matches(result)
+    }
+
+    @Test
+    fun fromJsonWithEJBlockAdapterSingleParagraph() {
+        val innerMoshi = Moshi.Builder()
+            .add(KotlinJsonAdapterFactory())
+            .build()
+
+        val moshi = Moshi.Builder()
+            .add(EJBlockAdapter(innerMoshi))
+            .build()
+
+        val result = moshi.adapter(EJBlock::class.java)
+            .fromJson(singleParagraph)
+
+        instanceOf<EJParagraphBlock>(EJParagraphBlock::class.java).matches(result)
+    }
+
+    companion object {
+        const val singleParagraph = "{\"type\": \"paragraph\",\"data\": {\"text\": \"Lorem ipsum bla bla\" } }"
+    }
+}

settings.gradle

@@ -1,3 +1,4 @@
 include ':app', ':editorjskit'
 rootProject.name='EditorJSKitSample'
 include ':gsonparser'
+include ':moshiparser'