#101 Added support for in-memory image provider in StyleXML

malcommac · malcommac · commit 64682e837179 · 2020-01-12T19:57:59.000+01:00
diff --git a/Sources/SwiftRichString/Extensions/AttributedString+Attachments.swift b/Sources/SwiftRichString/Extensions/AttributedString+Attachments.swift
@@ -76,16 +76,15 @@ public extension AttributedString {
         }
         
         let image = Image(named: imageNamed)
-        let boundsRect = CGRect(string: bounds)
-        self.init(image: image, bounds: boundsRect)
+        self.init(image: image, bounds: bounds)
     }
     
     /// Initialize a new attributed string from an image.
     ///
     /// - Parameters:
     ///   - image: image to use.
     ///   - bounds: location and size of the image, if `nil` the default bounds is applied.
-    convenience init?(image: Image?, bounds: CGRect? = nil) {
+    convenience init?(image: Image?, bounds: String? = nil) {
         guard let image = image else {
             return nil
         }
@@ -110,8 +109,8 @@ public extension AttributedString {
         }
         #endif
         
-        if let bounds = bounds {
-            attachment.bounds = bounds
+        if let boundsRect = CGRect(string: bounds) {
+            attachment.bounds = boundsRect
         }
         
         self.init(attachment: attachment)
diff --git a/Sources/SwiftRichString/Style/StyleGroup.swift b/Sources/SwiftRichString/Style/StyleGroup.swift
@@ -35,9 +35,11 @@ import AppKit
 import UIKit
 #endif
 
-public class StyleGroup: StyleProtocol {
+public typealias StyleGroup = StyleXML
+
+public class StyleXML: StyleProtocol {
     
-    // The following attributes are ignored for StyleGroup because are read from the sub styles.
+    // The following attributes are ignored for StyleXML because are read from the sub styles.
     public var attributes: [NSAttributedString.Key : Any] = [:]
     public var fontData: FontData? = nil
     public var textTransforms: [TextTransform]? = nil
@@ -49,23 +51,30 @@ public class StyleGroup: StyleProtocol {
     /// to the existing source.
     public var baseStyle: StyleProtocol?
     
-    /// Parsing options.
+    /// XML Parsing options.
     public var xmlParsingOptions: XMLParsingOptions = []
     
+    /// Mapped image for memory based images.
+    public private(set) var imagesMap: [String: UIImage]? = nil
+    
     /// Dynamic attributes resolver.
     /// By default the `StandardXMLAttributesResolver` instance is used.
     public var xmlAttributesResolver: XMLDynamicAttributesResolver = StandardXMLAttributesResolver()
     
     // MARK: - Initialization
     
-    /// Initialize a new `StyleGroup` with a dictionary of style and names.
+    /// Initialize a new `StyleXML` with a dictionary of style and names.
     /// Note: Ordered is not guarantee, use `init(_ styles:[(String, StyleProtocol)]` if you
     /// need to keep the order of the styles.
     ///
-    /// - Parameter styles: styles dictionary
-    public init(base: StyleProtocol? = nil, _ styles: [String: StyleProtocol]) {
+    /// - Parameters:
+    ///   - base: base style applied to the entire string.
+    ///   - styles: styles dictionary used to map your xml tags to styles definitions.
+    ///   - images: images used in XML. If a named image is not assigned here the default assets is used (aka `UIImage(named:)`).
+    public init(base: StyleProtocol? = nil, _ styles: [String: StyleProtocol] = [:], images: [String: UIImage]? = nil) {
         self.styles = styles
         self.baseStyle = base
+        self.imagesMap = images
     }
     
     // MARK: - Public Methods
@@ -133,9 +142,7 @@ public class StyleGroup: StyleProtocol {
     /// - Returns: modified attributed string, same instance of the `source`.
     public func apply(to attrStr: AttributedString, adding: Bool, range: NSRange?) -> AttributedString {
         do {
-            let xmlParser = XMLStringBuilder(string: attrStr.string, options: xmlParsingOptions,
-                                       baseStyle: baseStyle, styles: styles,
-                                       xmlAttributesResolver: xmlAttributesResolver)
+            let xmlParser = XMLStringBuilder(styleXML: self, string: attrStr.string)
             return try xmlParser.parse()
         } catch {
             debugPrint("Failed to generate attributed string from xml: \(error)")
diff --git a/Sources/SwiftRichString/Support/XMLDynamicAttributesResolver.swift b/Sources/SwiftRichString/Support/XMLDynamicAttributesResolver.swift
@@ -38,6 +38,16 @@ import UIKit
 // MARK: - XMLDynamicAttributesResolver
 
 public protocol XMLDynamicAttributesResolver {
+        
+    /// When an `img` tag is found this function is called to return requested image.
+    /// Default implementation of this method receive the `name` attribute of the `img` tag along with any mapping
+    /// provided by calling `StyleXML`, if `mapping` does not contains requested image for given name
+    /// the `UIImage(named:)` is called and image is searching inside any bundled `xcasset` file.
+    ///
+    /// - Parameters:
+    ///   - name: name of the image to get.
+    ///   - fromStyle: caller instance of `StyleXML.
+    func imageWithName(_ name: String, fromStyle style: StyleXML) -> UIImage?
     
     /// You are receiving this event when SwiftRichString correctly render an existing tag but the tag
     /// contains extra attributes you may want to handle.
@@ -47,7 +57,8 @@ public protocol XMLDynamicAttributesResolver {
     /// - Parameters:
     ///   - attributedString: attributed string. You will receive it after the style is applied.
     ///   - xmlStyle: xml style information with tag, applied style and the dictionary with extra attributes.
-    func applyDynamicAttributes(to attributedString: inout AttributedString, xmlStyle: XMLDynamicStyle)
+    ///   - fromStyle: caller instance of `StyleXML.
+    func applyDynamicAttributes(to attributedString: inout AttributedString, xmlStyle: XMLDynamicStyle, fromStyle: StyleXML)
     
     /// You will receive this event when SwiftRichString can't found a received style name into provided group tags.
     /// You can decide to handle it. The default receiver for example uses the `a` tag to render passed url if `href`
@@ -57,15 +68,29 @@ public protocol XMLDynamicAttributesResolver {
     ///   - tag: tag name received.
     ///   - attributedString: attributed string received.
     ///   - attributes: attributes of the tag received.
-    func styleForUnknownXMLTag(_ tag: String, to attributedString: inout AttributedString, attributes: [String: String]?)
+    ///   - fromStyle: caller instance of `StyleXML.
+    func styleForUnknownXMLTag(_ tag: String, to attributedString: inout AttributedString, attributes: [String: String]?, fromStyle: StyleXML)
 
 }
 
+extension XMLDynamicAttributesResolver {
+    
+    public func imageWithName(_ name: String, fromStyle style: StyleXML) -> UIImage? {
+        guard let mappedImage = style.imagesMap?[name] else {
+            return UIImage(named: name) // xcassets fallback
+        }
+
+        // origin xml style contains mapped image.
+        return mappedImage
+    }
+    
+}
+
 // MARK: - StandardXMLAttributesResolver
 
 open class StandardXMLAttributesResolver: XMLDynamicAttributesResolver {
     
-    public func applyDynamicAttributes(to attributedString: inout AttributedString, xmlStyle: XMLDynamicStyle) {
+    public func applyDynamicAttributes(to attributedString: inout AttributedString, xmlStyle: XMLDynamicStyle, fromStyle: StyleXML) {
         let finalStyleToApply = Style()
         xmlStyle.enumerateAttributes { key, value  in
             switch key {
@@ -80,7 +105,7 @@ open class StandardXMLAttributesResolver: XMLDynamicAttributesResolver {
         attributedString.add(style: finalStyleToApply)
     }
     
-    public func styleForUnknownXMLTag(_ tag: String, to attributedString: inout AttributedString, attributes: [String: String]?) {
+    public func styleForUnknownXMLTag(_ tag: String, to attributedString: inout AttributedString, attributes: [String: String]?, fromStyle: StyleXML) {
         let finalStyleToApply = Style()
         switch tag {
             case "a": // href support
@@ -99,8 +124,9 @@ open class StandardXMLAttributesResolver: XMLDynamicAttributesResolver {
                 #if os(iOS) || os(OSX)
                 // Local Image support
                 if let imageName = attributes?["named"] {
-                    if let image = AttributedString(imageNamed: imageName, bounds: attributes?["rect"]) {
-                        attributedString.append(image)
+                    if let image = imageWithName(imageName, fromStyle: fromStyle),
+                        let imageString = AttributedString(image: image, bounds: attributes?["rect"]) {
+                        attributedString.append(imageString)
                     }
                 }
                 #endif
diff --git a/Sources/SwiftRichString/Support/XMLStringBuilder.swift b/Sources/SwiftRichString/Support/XMLStringBuilder.swift
@@ -65,47 +65,54 @@ public class XMLStringBuilder: NSObject, XMLParserDelegate {
     private var xmlParser: XMLParser
     
     /// Parsing options.
-    private var options: XMLParsingOptions
+    private var options: XMLParsingOptions {
+        return styleXML.xmlParsingOptions
+    }
     
     /// Produced final attributed string
     private var attributedString: AttributedString
     
     /// Base style to apply as common style of the entire string.
-    private var baseStyle: StyleProtocol?
+    private var baseStyle: StyleProtocol? {
+        return styleXML.baseStyle
+    }
     
     /// Styles to apply.
-    private var styles: [String: StyleProtocol]
+    private var styles: [String: StyleProtocol] {
+        return styleXML.styles
+    }
     
     /// Styles applied at each fragment.
     private var xmlStylers = [XMLDynamicStyle]()
     
     /// XML Attributes resolver
-    public var xmlAttributesResolver: XMLDynamicAttributesResolver
+    public var xmlAttributesResolver: XMLDynamicAttributesResolver {
+        return styleXML.xmlAttributesResolver
+    }
 
     // The XML parser sometimes splits strings, which can break localization-sensitive
     // string transforms. Work around this by using the currentString variable to
     // accumulate partial strings, and then reading them back out as a single string
     // when the current element ends, or when a new one is started.
     var currentString: String?
     
+    /// StyleXML instance.
+    private weak var styleXML: StyleXML!
+        
     // MARK: - Initialization
 
-    public init(string: String, options: XMLParsingOptions,
-                baseStyle: StyleProtocol?, styles: [String: StyleProtocol],
-                xmlAttributesResolver: XMLDynamicAttributesResolver) {
-        let xml = (options.contains(.doNotWrapXML) ? string : "<\(XMLStringBuilder.topTag)>\(string)</\(XMLStringBuilder.topTag)>")
+    public init(styleXML: StyleXML, string: String) {
+        self.styleXML = styleXML
+
+        let xml = (styleXML.xmlParsingOptions.contains(.doNotWrapXML) ? string : "<\(XMLStringBuilder.topTag)>\(string)</\(XMLStringBuilder.topTag)>")
         guard let data = xml.data(using: String.Encoding.utf8) else {
             fatalError("Unable to convert to UTF8")
         }
         
-        self.options = options
         self.attributedString = NSMutableAttributedString()
-        self.xmlAttributesResolver = xmlAttributesResolver
         self.xmlParser = XMLParser(data: data)
-        self.baseStyle = baseStyle
-        self.styles = styles
         
-        if let baseStyle = baseStyle {
+        if let baseStyle = styleXML.baseStyle {
             self.xmlStylers.append( XMLDynamicStyle(tag: XMLStringBuilder.topTag, style: baseStyle) )
         }
         
@@ -180,11 +187,11 @@ public class XMLStringBuilder: NSObject, XMLParserDelegate {
                 newAttributedString = newAttributedString.add(style: style)
                 // Also apply the xml attributes if needed
                 if xmlStyle.xmlAttributes != nil {
-                    xmlAttributesResolver.applyDynamicAttributes(to: &newAttributedString, xmlStyle: xmlStyle)
+                    xmlAttributesResolver.applyDynamicAttributes(to: &newAttributedString, xmlStyle: xmlStyle, fromStyle: styleXML)
                 }
             } else {
                 // it's an unknown tag, we can call the resolver for unknown tags
-                xmlAttributesResolver.styleForUnknownXMLTag(xmlStyle.tag, to: &newAttributedString, attributes: xmlStyle.xmlAttributes)
+                xmlAttributesResolver.styleForUnknownXMLTag(xmlStyle.tag, to: &newAttributedString, attributes: xmlStyle.xmlAttributes, fromStyle: styleXML)
             }
 
         }
@@ -203,7 +210,7 @@ public class XMLDynamicStyle {
     /// Tag read for this style.
     public let tag: String
     
-    /// Style found in receiver `StyleGroup` instance.
+    /// Style found in receiver `StyleXML` instance.
     public let style: StyleProtocol?
     
     /// Attributes found into the xml tag.

Original file line number	Diff line number	Diff line change
`@@ -76,16 +76,15 @@ public extension AttributedString {`
`76`	`76`	`}`
`77`	`77`
`78`	`78`	`let image = Image(named: imageNamed)`
`79`		`- let boundsRect = CGRect(string: bounds)`
`80`		`- self.init(image: image, bounds: boundsRect)`
	`79`	`+ self.init(image: image, bounds: bounds)`
`81`	`80`	`}`
`82`	`81`
`83`	`82`	`/// Initialize a new attributed string from an image.`
`84`	`83`	`///`
`85`	`84`	`/// - Parameters:`
`86`	`85`	`/// - image: image to use.`
`87`	`86`	/// - bounds: location and size of the image, if `nil` the default bounds is applied.
`88`		`- convenience init?(image: Image?, bounds: CGRect? = nil) {`
	`87`	`+ convenience init?(image: Image?, bounds: String? = nil) {`
`89`	`88`	`guard let image = image else {`
`90`	`89`	`return nil`
`91`	`90`	`}`
`@@ -110,8 +109,8 @@ public extension AttributedString {`
`110`	`109`	`}`
`111`	`110`	`#endif`
`112`	`111`
`113`		`- if let bounds = bounds {`
`114`		`- attachment.bounds = bounds`
	`112`	`+ if let boundsRect = CGRect(string: bounds) {`
	`113`	`+ attachment.bounds = boundsRect`
`115`	`114`	`}`
`116`	`115`
`117`	`116`	`self.init(attachment: attachment)`