Merge pull request #2 from contentstack/feature/supercharge-rte

Feature/supercharge rte

Author: uttamukkoji

.slather.yml

@@ -5,3 +5,4 @@ scheme: ContentstackUtils-Package
 ignore:
   - "Tests/*"
   - "Sources/Kanna/*"
+  - "Sources/ContentstackUtils/Decodable.*"

.talismanrc

@@ -0,0 +1,5 @@
+fileignoreconfig:
+- filename: README.md
+  allowed_patterns: [API_KEY, DELIVERY_TOKEN, ENVIRONMENT]
+- filename: ContentstackUtils.xcodeproj/project.pbxproj
+  checksum: 5b62a76622fed7df9967d8646467bd2f04c221df2c95eddce7541fd8ab448078

ContentstackUtils.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
 s.name             = 'ContentstackUtils'
-s.version          = '1.1.1'
+s.version          = '1.1.2'
 s.summary          = 'Contentstack is a headless CMS with an API-first approach that puts content at the centre.'
 
 s.description      = <<-DESC

ContentstackUtils.xcodeproj/project.pbxproj

@@ -82,54 +82,84 @@ To render embedded items on the front-end, create a class implementing Option pr
 import Foundation  
 import ContentstackUtils  
 class  CustomRenderOption: Option {  
-var entry: EntryEmbedable  
-  
-init(entry: EntryEmbedable) {  
-    self.entry = entry  
-}  
+
+override func renderMark(markType: MarkType, text: String) -> String {
+    switch markType {
+    case .bold:
+        return "<b>\(text)</b>"
+    default:
+        return super.renderMark(markType: markType, text: text)
+    }
+}
+
+override func renderNode(nodeType: String, node: Node, next: (([Node]) -> String)) -> String {
+    switch nodeType {
+    case "p":
+        return "<p class='class-id'>\(next(node.children))</p>"
+    case "h1":
+        return "<h1 class='class-id'>\(next(node.children))</h1>"
+    default:
+        return super.renderNode(nodeType: nodeType, node: node, next: next)
+    }
+}
   
-func  renderOptions(embeddedObject: EmbeddedObject, metadata: Metadata) -> String? {  
-    var result = ""  
-    switch metadata.styleType {  
-        case .block:  
-            if metadata.contentTypeUid == 'product' {  
-                result = """  
-                    <div>  
-                    <h2 >\(embeddedObject.title)</h2>  
-                    <img src=\(embeddedObject.product_image.url) alt=\(embeddedObject.product_image.title)/>  
-                    <p>\(embeddedObject.price)</p>  
-                    </div>  
-                """  
-            }else {  
-                result = """  
-                    <div>  
-                    <h2>\(entry.title)</h2>  
-                    <p>\(entry.description)</p>  
-                    </div>  
-                """              
-            }  
-        case .inline:  
-            result = "<span><b>\(embeddedObject.title)</b> - \(embeddedObject.description)</span>"  
-        case .link:  
-            result = "<a href=\(metadata.attributes.href)>\(metadata.text)</a>"  
-        case .display:  
-            result = "<img src=\(metadata.attributes.src) alt=\(metadata.alt) />"  
-        case .download:  
-            result = "<a href=\(metadata.attributes.href)>\(metadata.text)</a>"  
-        }  
-        return result  
-    }  
+func renderOptions(embeddedObject: EmbeddedObject, metadata: Metadata) -> String? {
+      switch metadata.styleType {
+      case .block:
+          if metadata.contentTypeUid == "product" {
+              if let product = embeddedObject as? Product {
+                  return """
+                      <div>
+                      <h2 >\(product.title)</h2>
+                      <img src=\(product.product_image.url) alt=\(product.product_image.title)/>
+                      <p>\(product.price)</p>
+                      </div>
+                  """
+              }
+          }else {
+              if let entry = embeddedObject as? Entry {
+                  return """
+                      <div>
+                      <h2>\(entry.title)</h2>
+                      <p>\(entry.description)</p>
+                      </div>
+                      """
+              }
+          }
+      default:
+          return super.renderOptions(embeddedObject: embeddedObject, metadata: metadata)
+      }
 }
 ```
 
 ## Basic Queries
 Contentstack Utils SDK lets you interact with the Content Delivery APIs and retrieve embedded items from the RTE field of an entry.
 
 ### Fetch Embedded Item(s) from a Single Entry
+#### Render HTML RTE Embedded object
+To get an embedded items of a single entry, you need to provide the stack API key, environment name, delivery token, content type and entry UID. Then, use the `ContentstackUtils.render` functions as shown below:
+```swift
+import ContentstackUtils  
+
+let stack:Stack = Contentstack.stack(apiKey: API_KEY, deliveryToken: DELIVERY_TOKEN, environment: ENVIRONMENT)  
 
-To get an embedded items of a single entry, you need to provide the stack API key, environment name, delivery token, content type and entry UID. Then, use the Contentstack.Utils.render functions as shown below:
+stack.contentType(uid: contentTypeUID)
+     .entry(uid: entryUID)
+     .include(.embeddedItems)  
+     .fetch { (result: Result<EntryModel, Error>, response: ResponseType) in  
+        switch result {  
+            case .success(let model):
+                ContentstackUtils.render(content: model.richTextContent, Option(entry: model))  
+            case .failure(let error):  
+                //Error Message  
+        }  
+    }
 ```
-import ContentstackSwift  
+
+#### Render Supercharged RTE contents
+To get a single entry, you need to provide the stack API key, environment name, delivery token, content type and entry UID. Then, use `ContentstackUtils.jsonToHtml` function as shown below:
+```swift
+import ContentstackUtils  
 
 let stack:Stack = Contentstack.stack(apiKey: API_KEY, deliveryToken: DELIVERY_TOKEN, environment: ENVIRONMENT)  
 
@@ -139,16 +169,19 @@ stack.contentType(uid: contentTypeUID)
      .fetch { (result: Result<EntryModel, Error>, response: ResponseType) in  
         switch result {  
             case .success(let model):
-                Contentstack.Utils.render(content: model.richTextContent, DefaultRender(entry: model))  
+                ContentstackUtils.jsonToHtml(content: model.richTextContent, Option(entry: model))  
             case .failure(let error):  
                 //Error Message  
         }  
     }
 ```
+> Node: Supercharged RTE also supports Embedded items to get all embedded items while fetching entry use `includeEmbeddedItems` function.
+
 ### Fetch Embedded Item(s) from Multiple Entries
-To get embedded items from multiple entries, you need to provide the stack API key, environment name, delivery token, and content type UID. Then, use the Contentstack.Utils.render functions as shown below:
+#### Render HTML RTE Embedded object
+To get embedded items from multiple entries, you need to provide the stack API key, environment name, delivery token, and content type UID. Then, use the `ContentstackUtils.render` functions as shown below:
 ```
-import ContentstackSwift  
+import ContentstackUtils  
 
 let stack = Contentstack.stack(apiKey: apiKey,  
 deliveryToken: deliveryToken,  
@@ -162,10 +195,33 @@ stack.contentType(uid: contentTypeUID)
         switch result {  
             case .success(let contentstackResponse):  
                 for item in contentstackResponse.items {  
-                    Contentstack.Utils.render(content: item.richTextContent, CustomRenderOption(entry: item))  
+                    ContentstackUtils.render(content: item.richTextContent, CustomRenderOption(entry: item))  
                 }  
             case .failure(let error):  
                 //Error Message  
         }  
     }
 ```
+
+#### Render Supercharged RTE contents
+To get a Multiple entry, you need to provide the stack API key, environment name, delivery token, and content type UID. Then, use `Contentstack.Utils.jsonToHtml` function as shown below:
+```swift
+import ContentstackUtils  
+
+let stack:Stack = Contentstack.stack(apiKey: API_KEY, deliveryToken: DELIVERY_TOKEN, environment: ENVIRONMENT)  
+
+stack.contentType(uid: contentTypeUID)
+     .entry()
+     .query()
+     .include(.embeddedItems)
+     .find { (result: Result<EntryModel, Error>, response: ResponseType) in  
+        switch result {  
+            case .success(let model):
+                for item in contentstackResponse.items {  
+                    ContentstackUtils.jsonToHtml(content: item.richTextContent, CustomRenderOption(entry: item))  
+                }
+            case .failure(let error):  
+                //Error Message  
+        }  
+    }
+```

README.md

@@ -10,8 +10,9 @@ public struct ContentstackUtils {
                 .findEmbeddedObject { (model) in
                     if let outerHTML = model.outerHTML {
                         var replaceString = ""
-                        if let embeddedObject = findObject(model, entry: option.entry) {
-                            if let string = option.renderOptions(
+                        if let entry = option.entry,
+                           let embeddedObject = findObject(model, entry: entry) {
+                            if let string = option.renderItem(
                                 embeddedObject: embeddedObject,
                                 metadata: model) {
                                 replaceString = string
@@ -38,7 +39,74 @@ public struct ContentstackUtils {
             throw error
         }
     }
+    
+    
+    public static func jsonToHtml(node documents: [Node], _ option: Option = Option()) -> [String] {
+        var resultContents: [String] = []
+        documents.forEach { (document) in
+            resultContents.append(jsonToHtml(node: document, option))
+        }
+        return resultContents
+    }
 
+    public static func jsonToHtml(node document: Node, _ option: Option = Option()) -> String {
+        return nodeChildrenToHtml(children: document.children, option)
+    }
+
+    static private func nodeChildrenToHtml(children nodes:[Node], _ option: Option) -> String {
+        nodes.map{ (node) -> String in
+            return nodeToHtml(node, option)
+        }.joined()
+    }
+    
+    static private func nodeToHtml(_ node: Node, _ option: Option) -> String {
+        switch node.type {
+        case NodeType.text.rawValue:
+            return textNodeToHtml(node as! TextNode, option)
+        case  NodeType.reference.rawValue:
+            return referenceToHtml(node, option)
+        default:
+            return option.renderNode(nodeType: node.type, node: node) { (children) -> String in
+                return nodeChildrenToHtml(children: children, option)
+            }
+        }
+    }
+    
+    static private func textNodeToHtml(_ textNode: TextNode, _ option: Option) -> String {
+        var text = textNode.text
+        if (textNode.superscript) {
+            text = option.renderMark(markType: .superscript, text: text)
+        }
+        if (textNode.subscript) {
+            text = option.renderMark(markType: .subscript, text: text)
+        }
+        if (textNode.inlineCode) {
+            text = option.renderMark(markType: .inlineCode, text: text)
+        }
+        if (textNode.strikethrough) {
+            text = option.renderMark(markType: .strikethrough, text: text)
+        }
+        if (textNode.underline) {
+            text = option.renderMark(markType: .underline, text: text)
+        }
+        if (textNode.italic) {
+            text = option.renderMark(markType: .italic, text: text)
+        }
+        if (textNode.bold) {
+            text = option.renderMark(markType: .bold, text: text)
+        }
+        return text
+    }
+    
+    static private func referenceToHtml(_ node: Node, _ option: Option) -> String {
+        let metadata = Metadata(nodeAttribute: node.attrs, text: node.children.count > 0 ? (node.children.first as? TextNode)?.text : "")
+        if let entry = option.entry,
+           let embeddedObject = findObject(metadata, entry: entry) {
+            return option.renderItem(embeddedObject: embeddedObject, metadata: metadata) ?? ""
+        }
+        return ""
+    }
+    
     static private func findObject(_ model: Metadata, entry: EntryEmbedable) -> EmbeddedObject? {
         if let items = entry.embeddedItems, let uid = model.itemUid, let contentTypeUID = model.contentTypeUid {
             for (_, value) in items {

Sources/ContentstackUtils/ContentstackUtils.swift

@@ -0,0 +1,93 @@
+//
+//  Decodable.swift
+//  ContentstackUtils
+//
+//  Created by Uttam Ukkoji on 04/06/21.
+//
+
+internal struct JSONCodingKeys: CodingKey {
+    internal var stringValue: String
+    internal init?(stringValue: String) {
+        self.stringValue = stringValue
+    }
+    internal var intValue: Int?
+    internal init?(intValue: Int) {
+        self.init(stringValue: "\(intValue)")
+        self.intValue = intValue
+    }
+}
+
+internal extension KeyedDecodingContainer {
+
+    func decode(_ type: Dictionary<String, Any>.Type, forKey key: K) throws -> [String: Any] {
+        let container = try self.nestedContainer(keyedBy: JSONCodingKeys.self, forKey: key)
+        return try container.decode(type)
+    }
+
+    func decodeIfPresent(_ type: Dictionary<String, Any>.Type, forKey key: K) throws -> [String: Any]? {
+        guard contains(key) else { return nil }
+        guard try decodeNil(forKey: key) == false else { return nil }
+        return try decode(type, forKey: key)
+    }
+
+    func decode(_ type: Array<Any>.Type, forKey key: K) throws -> [Any] {
+        var container = try self.nestedUnkeyedContainer(forKey: key)
+        return try container.decode(type)
+    }
+
+    func decodeIfPresent(_ type: Array<Any>.Type, forKey key: K) throws -> [Any]? {
+        guard contains(key) else { return nil }
+        guard try decodeNil(forKey: key) == false else { return nil }
+        return try decode(type, forKey: key)
+    }
+
+    func decode(_ type: Dictionary<String, Any>.Type) throws -> [String: Any] {
+        var dictionary = [String: Any]()
+        for key in allKeys {
+            if let boolValue = try? decode(Bool.self, forKey: key) {
+                dictionary[key.stringValue] = boolValue
+            } else if let stringValue = try? decode(String.self, forKey: key) {
+                dictionary[key.stringValue] = stringValue
+            } else if let intValue = try? decode(Int.self, forKey: key) {
+                dictionary[key.stringValue] = intValue
+            } else if let doubleValue = try? decode(Double.self, forKey: key) {
+                dictionary[key.stringValue] = doubleValue
+            } else if let nestedDictionary = try? decode(Dictionary<String, Any>.self, forKey: key) {
+                dictionary[key.stringValue] = nestedDictionary
+            } else if let nestedArray = try? decode(Array<Any>.self, forKey: key) {
+                dictionary[key.stringValue] = nestedArray
+            }
+        }
+        return dictionary
+    }
+}
+
+internal extension UnkeyedDecodingContainer {
+
+    mutating func decode(_ type: Array<Any>.Type) throws -> [Any] {
+        var array: [Any] = []
+        while isAtEnd == false {
+            if try decodeNil() {
+                continue
+            } else if let value = try? decode(Bool.self) {
+                array.append(value)
+            } else if let value = try? decode(Int.self) {
+                array.append(value)
+            } else if let value = try? decode(Double.self) {
+                array.append(value)
+            } else if let value = try? decode(String.self) {
+                array.append(value)
+            } else if let nestedDictionary = try? decode(Dictionary<String, Any>.self) {
+                array.append(nestedDictionary)
+            } else if let nestedArray = try? decode(Array<Any>.self) {
+                array.append(nestedArray)
+            }
+        }
+        return array
+    }
+
+    mutating func decode(_ type: [String: Any].Type) throws -> [String: Any] {
+        let nestedContainer = try self.nestedContainer(keyedBy: JSONCodingKeys.self)
+        return try nestedContainer.decode(type)
+    }
+}

Sources/ContentstackUtils/Decodable.swift

@@ -0,0 +1,10 @@
+//
+//  MarkType.swift
+//  ContentstackUtils
+//
+//  Created by Uttam Ukkoji on 03/06/21.
+//
+
+public enum MarkType: String {
+    case bold, italic, underline, strikethrough, inlineCode, `subscript`, superscript
+}