├── .github
    └── workflows
    │   └── swift.yml
├── .gitignore
├── Assets
    ├── simple_string_semantic.png
    └── simple_string_visual.png
├── AttributedStringStyle.podspec
├── CHANGELOG.md
├── LICENSE
├── Package.swift
├── README.md
├── Sources
    └── AttributedStringStyle
    │   ├── AttributedStringBuilder.swift
    │   ├── AttributedStringStyler.swift
    │   ├── NSAttributedString+Style.swift
    │   └── NSAttributedString.Key+Style.swift
└── Tests
    ├── AttributedStringStyleTests
        ├── AttributedStringBuilderTests.swift
        ├── AttributedStringStylerTests.swift
        ├── TestUtils.swift
        └── XCTestManifests.swift
    └── LinuxMain.swift


/.github/workflows/swift.yml:
--------------------------------------------------------------------------------
 1 | name: Swift
 2 | 
 3 | on: [push]
 4 | 
 5 | jobs:
 6 |   build:
 7 | 
 8 |     runs-on: macOS-latest
 9 | 
10 |     steps:
11 |     - uses: actions/checkout@v1
12 |     - name: Build
13 |       run: swift build -v
14 |     - name: Run tests
15 |       run: swift test -v
16 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # OS X
 2 | .DS_Store
 3 | 
 4 | # Xcode
 5 | build/
 6 | *.pbxuser
 7 | !default.pbxuser
 8 | *.mode1v3
 9 | !default.mode1v3
10 | *.mode2v3
11 | !default.mode2v3
12 | *.perspectivev3
13 | !default.perspectivev3
14 | xcuserdata/
15 | *.xccheckout
16 | profile
17 | *.moved-aside
18 | DerivedData
19 | *.hmap
20 | *.ipa
21 | 
22 | # Bundler
23 | .bundle
24 | 
25 | # Add this line if you want to avoid checking in source code from Carthage dependencies.
26 | # Carthage/Checkouts
27 | 
28 | Carthage/Build
29 | 
30 | # We recommend against adding the Pods directory to your .gitignore. However
31 | # you should judge for yourself, the pros and cons are mentioned at:
32 | # https://guides.cocoapods.org/using/using-cocoapods.html#should-i-ignore-the-pods-directory-in-source-control
33 | #
34 | # Note: if you ignore the Pods directory, make sure to uncomment
35 | # `pod install` in .travis.yml
36 | #
37 | Example/Pods/
38 | /.build
39 | /AttributedStringStyle.xcodeproj
40 | 


--------------------------------------------------------------------------------
/Assets/simple_string_semantic.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/felginep/AttributedStringStyle/97dd0462a70b6a254af5995c1ed5846e0715866a/Assets/simple_string_semantic.png


--------------------------------------------------------------------------------
/Assets/simple_string_visual.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/felginep/AttributedStringStyle/97dd0462a70b6a254af5995c1ed5846e0715866a/Assets/simple_string_visual.png


--------------------------------------------------------------------------------
/AttributedStringStyle.podspec:
--------------------------------------------------------------------------------
 1 | #
 2 | # Be sure to run `pod lib lint AttributedStringStyle.podspec' to ensure this is a
 3 | # valid spec before submitting.
 4 | #
 5 | # Any lines starting with a # are optional, but their use is encouraged
 6 | # To learn more about a Podspec see https://guides.cocoapods.org/syntax/podspec.html
 7 | #
 8 | 
 9 | Pod::Spec.new do |s|
10 |   s.name             = 'AttributedStringStyle'
11 |   s.version          = '1.0.1'
12 |   s.summary          = 'Focus on the semantic and the visual representation of NSAttributedString separately.'
13 |   s.homepage         = 'https://github.com/felginep/AttributedStringStyle'
14 |   s.license          = { :type => 'MIT', :file => 'LICENSE' }
15 |   s.author           = 'Pierre Felgines'
16 |   s.social_media_url = 'http://twitter.com/PierreFelgines'
17 |   s.source           = { :git => 'https://github.com/felginep/AttributedStringStyle.git', :tag => "v#{s.version}" }
18 |   s.ios.deployment_target = '9.0'
19 |   s.source_files = 'Sources/**/*'
20 |   s.framework    = 'Foundation'
21 |   s.swift_version = '5.0'
22 | end
23 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
 1 | # Change Log
 2 | All notable changes to this project will be documented in this file.
 3 | `AttributedStringStyle` adheres to [Semantic Versioning](http://semver.org/).
 4 | 
 5 | ## [1.0.1]
 6 | 
 7 | ### Updated
 8 | 
 9 | - Update example project settings
10 | - Remove redundant public declaration to fix warning
11 | 
12 | ## [1.0.0]
13 | 
14 | - First version
15 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2018 Pierre Felgines
 2 | 
 3 | Permission is hereby granted, free of charge, to any person obtaining a copy
 4 | of this software and associated documentation files (the "Software"), to deal
 5 | in the Software without restriction, including without limitation the rights
 6 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 7 | copies of the Software, and to permit persons to whom the Software is
 8 | furnished to do so, subject to the following conditions:
 9 | 
10 | The above copyright notice and this permission notice shall be included in
11 | all copies or substantial portions of the Software.
12 | 
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19 | THE SOFTWARE.
20 | 


--------------------------------------------------------------------------------
/Package.swift:
--------------------------------------------------------------------------------
 1 | // swift-tools-version:5.1
 2 | // The swift-tools-version declares the minimum version of Swift required to build this package.
 3 | 
 4 | import PackageDescription
 5 | 
 6 | let package = Package(
 7 |     name: "AttributedStringStyle",
 8 |     products: [
 9 |         // Products define the executables and libraries produced by a package, and make them visible to other packages.
10 |         .library(
11 |             name: "AttributedStringStyle",
12 |             targets: ["AttributedStringStyle"]),
13 |     ],
14 |     dependencies: [
15 |         // Dependencies declare other packages that this package depends on.
16 |         // .package(url: /* package url */, from: "1.0.0"),
17 |     ],
18 |     targets: [
19 |         // Targets are the basic building blocks of a package. A target can define a module or a test suite.
20 |         // Targets can depend on other targets in this package, and on products in packages which this package depends on.
21 |         .target(
22 |             name: "AttributedStringStyle",
23 |             dependencies: []),
24 |         .testTarget(
25 |             name: "AttributedStringStyleTests",
26 |             dependencies: ["AttributedStringStyle"]),
27 |     ]
28 | )
29 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # AttributedStringStyle
 2 | 
 3 | [![Version](https://img.shields.io/cocoapods/v/AttributedStringStyle.svg?style=flat)](https://cocoapods.org/pods/AttributedStringStyle)
 4 | [![License](https://img.shields.io/cocoapods/l/AttributedStringStyle.svg?style=flat)](https://cocoapods.org/pods/AttributedStringStyle)
 5 | [![Platform](https://img.shields.io/cocoapods/p/AttributedStringStyle.svg?style=flat)](https://cocoapods.org/pods/AttributedStringStyle)
 6 | 
 7 | ## Blog post
 8 | 
 9 | You can find the associated blog post [here](https://felginep.github.io/2018-11-23/attributed-string-with-style).
10 | 
11 | ## Example
12 | 
13 | To run the example project, clone the repo, and run `pod install` from the Example directory first.
14 | 
15 | ## Requirements
16 | 
17 | - iOS 9.0+
18 | - Swift 4.2
19 | 
20 | ## Installation
21 | 
22 | AttributedStringStyle is available through [CocoaPods](https://cocoapods.org). To install
23 | it, simply add the following line to your Podfile:
24 | 
25 | ```ruby
26 | pod 'AttributedStringStyle'
27 | ```
28 | 
29 | ## How to use it
30 | 
31 | Define some abstract style anywhere in your app. For instance.
32 | 
33 | ```swift
34 | enum Style {
35 |     case regular
36 |     case highlighted
37 | }
38 | ```
39 | 
40 | Once your style is defined we have two tools at your disposal:
41 | - `AttributedStringBuilder` that is helpful to create attributed string with styles for range of characters
42 | - `AttributedStringStyler` that defines which visual attributes to apply for each style
43 | 
44 | To create your attributed string and focus on the semantic and not the display, use the builder like so:
45 | 
46 | ```swift
47 | let content = "A simple string"
48 | let builder = AttributedStringBuilder<Style>(string: content)
49 | builder.setStyle(.regular)
50 | let range = NSString(string: content).range(of: "simple")
51 | builder.addStyle(.highlighted, range: range)
52 | let semanticAttributedString = builder.build()
53 | ```
54 | 
55 | The attributed string has no visual attributes but semantics ones.
56 | 
57 | ![Simple String Semantics](https://raw.githubusercontent.com/felginep/AttributedStringStyle/master/Assets/simple_string_semantic.png)
58 | 
59 | Once your semantic content is defined, you can use the styler to create a new attributed string with visual attributes.
60 | 
61 | ```swift
62 | let styler = AttributedStringStyler<Style>()
63 | styler.register(
64 |     attributes: [
65 |         .font: UIFont.systemFont(ofSize: 14),
66 |         .foregroundColor: UIColor.gray
67 |     ],
68 |     forStyle: .regular
69 | )
70 | styler.register(
71 |     attributes: [
72 |         .font: UIFont.boldSystemFont(ofSize: 14),
73 |         .foregroundColor: UIColor.black
74 |     ],
75 |     forStyle: .highlighted
76 | )
77 | 
78 | let visualAttributedString = semanticAttributedString.styled(with: styler)
79 | ```
80 | 
81 | This time the result is visual.
82 | 
83 | ![Simple String Visual](https://raw.githubusercontent.com/felginep/AttributedStringStyle/master/Assets/simple_string_visual.png)
84 | 
85 | ## Author
86 | 
87 | [Pierre Felgines](https://twitter.com/PierreFelgines)
88 | 
89 | ## License
90 | 
91 | AttributedStringStyle is available under the MIT license. See the LICENSE file for more info.
92 | 


--------------------------------------------------------------------------------
/Sources/AttributedStringStyle/AttributedStringBuilder.swift:
--------------------------------------------------------------------------------
 1 | //
 2 | //  AttributedStringBuilder.swift
 3 | //  AttributedStringStyle
 4 | //
 5 | //  Created by Pierre Felgines on 23/11/2018.
 6 | //
 7 | 
 8 | import Foundation
 9 | 
10 | public class AttributedStringBuilder<Style> {
11 | 
12 |     private var attributedString: NSMutableAttributedString
13 | 
14 |     // MARK: - Init
15 | 
16 |     public init(string: String) {
17 |         self.attributedString = NSMutableAttributedString(string: string)
18 |     }
19 | 
20 |     public init(attributedString: NSAttributedString) {
21 |         self.attributedString = NSMutableAttributedString(attributedString: attributedString)
22 |     }
23 | 
24 |     // MARK: - Public
25 | 
26 |     /**
27 |      Returns the backing attributed string
28 |      */
29 |     public func build() -> NSAttributedString {
30 |         return NSAttributedString(attributedString: attributedString)
31 |     }
32 | 
33 |     /**
34 |      Adds the given style to all the characters
35 |      - parameter style: Style to apply to the attributed string
36 |      */
37 |     public func addStyle(_ style: Style) {
38 |         addStyle(
39 |             style,
40 |             range: NSRange(location: 0, length: attributedString.length)
41 |         )
42 |     }
43 | 
44 |     /**
45 |      Adds the given style to the characters in the specified range
46 |      - parameter style: Style to apply to the attributed string
47 |      - parameter range: The range of characters to which the style apply.
48 |      */
49 |     public func addStyle(_ style: Style, range: NSRange) {
50 |         attributedString.addAttributes(
51 |             [.semanticStyle: style],
52 |             range: range
53 |         )
54 |     }
55 | 
56 |     /**
57 |      Sets the given style to all the characters
58 |      - parameter style: Style to apply to the attributed string
59 |      */
60 |     public func setStyle(_ style: Style) {
61 |         setStyle(
62 |             style,
63 |             range: NSRange(location: 0, length: attributedString.length)
64 |         )
65 |     }
66 | 
67 |     /**
68 |      Sets the given style to the characters in the specified range
69 |      - parameter style: Style to apply to the attributed string
70 |      - parameter range: The range of characters to which the style apply.
71 |      */
72 |     public func setStyle(_ style: Style, range: NSRange) {
73 |         attributedString.setAttributes(
74 |             [.semanticStyle: style],
75 |             range: range
76 |         )
77 |     }
78 | }
79 | 


--------------------------------------------------------------------------------
/Sources/AttributedStringStyle/AttributedStringStyler.swift:
--------------------------------------------------------------------------------
 1 | //
 2 | //  AttributedStringStyler.swift
 3 | //  TrainingJonathan
 4 | //
 5 | //  Created by Pierre Felgines on 23/11/2018.
 6 | //
 7 | 
 8 | import Foundation
 9 | 
10 | public class AttributedStringStyler<Style: Hashable> {
11 | 
12 |     public typealias Attributes = [NSAttributedString.Key: Any]
13 | 
14 |     private var styleToAttributes: [Style: Attributes] = [:]
15 | 
16 |     public init() {}
17 | 
18 |     // MARK: - Public
19 | 
20 |     /**
21 |      Register attributes for a style
22 |      - parameter attributes: A dictionary containing the attributes to add.
23 |      - parameter style: A style for which attributes are registered
24 |      */
25 |     public func register(attributes: Attributes, forStyle style: Style) {
26 |         styleToAttributes[style] = attributes
27 |     }
28 | 
29 |     /**
30 |      Create a new attributed string where all style occurrences are replaced with registered attributes
31 |      - parameter input: The input attribtued string
32 |      - returns: A newly created attributed string with attributes and no more style occurrences
33 |      */
34 |     public func attributedString(from input: NSAttributedString) -> NSAttributedString {
35 |         let attributedString = NSMutableAttributedString(attributedString: input)
36 |         attributedString.enumerateAttributes(
37 |             in: NSRange(location: 0, length: attributedString.length),
38 |             options: NSAttributedString.EnumerationOptions(rawValue: 0)
39 |         ) { (attributes, range, _) in
40 |             guard let value = attributes[.semanticStyle] as? Style else {
41 |                 return
42 |             }
43 |             attributedString.removeAttribute(.semanticStyle, range: range)
44 |             attributedString.addAttributes(styleToAttributes[value] ?? [:], range: range)
45 |         }
46 |         return (attributedString.copy() as? NSAttributedString) ?? input
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/Sources/AttributedStringStyle/NSAttributedString+Style.swift:
--------------------------------------------------------------------------------
 1 | //
 2 | //  NSAttributedString+Style.swift
 3 | //  AttributedStringStyle
 4 | //
 5 | //  Created by Pierre Felgines on 23/11/2018.
 6 | //
 7 | 
 8 | import Foundation
 9 | 
10 | public extension NSAttributedString {
11 | 
12 |     func styled<T>(with styler: AttributedStringStyler<T>) -> NSAttributedString {
13 |         return styler.attributedString(from: self)
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/Sources/AttributedStringStyle/NSAttributedString.Key+Style.swift:
--------------------------------------------------------------------------------
 1 | //
 2 | //  NSAttributedString.Key+Style.swift
 3 | //  AttributedStringStyle
 4 | //
 5 | //  Created by Pierre Felgines on 23/11/2018.
 6 | //
 7 | 
 8 | import Foundation
 9 | 
10 | extension NSAttributedString.Key {
11 | 
12 |     public static var semanticStyle: NSAttributedString.Key {
13 |         return NSAttributedString.Key(rawValue: "semanticStyle")
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/Tests/AttributedStringStyleTests/AttributedStringBuilderTests.swift:
--------------------------------------------------------------------------------
  1 | //
  2 | //  AttributedStringStyleTests.swift
  3 | //  AttributedStringStyleTests
  4 | //
  5 | //  Created by Pierre Felgines on 23/11/2018.
  6 | //
  7 | 
  8 | import XCTest
  9 | import AttributedStringStyle
 10 | 
 11 | private enum Style: String, CaseIterable {
 12 |     case style1
 13 |     case style2
 14 |     case style3
 15 | }
 16 | 
 17 | extension NSAttributedString {
 18 |     fileprivate func verifyStyle(_ style: Style, in range: NSRange) {
 19 |         verifyAttributes(in: range) { (attributes, foundRange) in
 20 |             XCTAssertNotNil(attributes[.semanticStyle])
 21 |             let foundStyle = attributes[.semanticStyle] as? Style
 22 |             XCTAssertEqual(foundStyle, style)
 23 |             XCTAssertEqual(foundRange, range)
 24 |         }
 25 |     }
 26 | 
 27 |     fileprivate func verifyStyle(_ style: Style) {
 28 |         verifyStyle(style, in: fullRange)
 29 |     }
 30 | }
 31 | 
 32 | final class AttributedStringBuilderTests: XCTestCase {
 33 | 
 34 |     func testAddOneStyle() {
 35 |         // Given
 36 |         let string = "Style"
 37 |         let builder = AttributedStringBuilder<Style>(string: string)
 38 | 
 39 |         // When
 40 |         builder.addStyle(.style1)
 41 |         let attributedString = builder.build()
 42 | 
 43 |         // Then
 44 |         attributedString.verifyStyle(.style1)
 45 |     }
 46 | 
 47 |     func testSetTwoStyles() {
 48 |         // Given
 49 |         let string = "Style"
 50 |         let builder = AttributedStringBuilder<Style>(string: string)
 51 | 
 52 |         // When
 53 |         builder.setStyle(.style1)
 54 |         builder.setStyle(.style2)
 55 |         let attributedString = builder.build()
 56 | 
 57 |         // Then
 58 |         attributedString.verifyStyle(.style2)
 59 |     }
 60 | 
 61 |     func testSetMultipleStyles() {
 62 |         // Given
 63 |         let string = Style.allCases.map { $0.rawValue }.joined(separator: " ")
 64 |         let builder = AttributedStringBuilder<Style>(string: string)
 65 | 
 66 |         // When
 67 |         for style in Style.allCases {
 68 |             let styleRange = NSString(string: string).range(of: style.rawValue)
 69 |             builder.setStyle(style, range: styleRange)
 70 |         }
 71 |         let attributedString = builder.build()
 72 | 
 73 |         // Then
 74 |         for style in Style.allCases {
 75 |             let styleRange = NSString(string: string).range(of: style.rawValue)
 76 |             attributedString.verifyStyle(style, in: styleRange)
 77 |         }
 78 |     }
 79 | 
 80 |     func testAddMultipleStylesInAttributedString() {
 81 |         // Given
 82 |         let string = Style.allCases.map { $0.rawValue }.joined(separator: " ")
 83 |         let input = NSAttributedString(string: string, attributes: [.test_foregroundColor: "red"])
 84 |         let builder = AttributedStringBuilder<Style>(attributedString: input)
 85 | 
 86 |         // When
 87 |         for style in Style.allCases {
 88 |             let styleRange = NSString(string: string).range(of: style.rawValue)
 89 |             builder.addStyle(style, range: styleRange)
 90 |         }
 91 |         let attributedString = builder.build()
 92 | 
 93 |         // Then
 94 |         for style in Style.allCases {
 95 |             let styleRange = NSString(string: string).range(of: style.rawValue)
 96 |             attributedString.verifyAttributes(in: styleRange) { (attributes, _) in
 97 |                 let keys: [NSAttributedString.Key] = Array(attributes.keys)
 98 |                     .sorted { $0.rawValue < $1.rawValue }
 99 |                 let expectedKeys: [NSAttributedString.Key] = [.semanticStyle, .test_foregroundColor]
100 |                     .sorted { $0.rawValue < $1.rawValue }
101 |                 XCTAssertEqual(keys, expectedKeys)
102 |             }
103 |         }
104 |     }
105 | 
106 |     static var allTests = [
107 |         ("testAddOneStyle", testAddOneStyle),
108 |         ("testSetTwoStyles", testSetTwoStyles),
109 |         ("testSetMultipleStyles", testSetMultipleStyles),
110 |         ("testAddMultipleStylesInAttributedString", testAddMultipleStylesInAttributedString),
111 |     ]
112 | }
113 | 


--------------------------------------------------------------------------------
/Tests/AttributedStringStyleTests/AttributedStringStylerTests.swift:
--------------------------------------------------------------------------------
 1 | //
 2 | //  AttributedStringStylerTests.swift
 3 | //  AttributedStringStyleTests
 4 | //
 5 | //  Created by Pierre Felgines on 26/11/2018.
 6 | //
 7 | 
 8 | import Foundation
 9 | import AttributedStringStyle
10 | import XCTest
11 | 
12 | private enum Style: String, CaseIterable {
13 |     case red
14 |     case green
15 |     case blue
16 | 
17 |     // (Pierre Felgines) 10/12/2019 Do not use UIColor here because we can't import UIKit in SPM tests
18 |     var color: String {
19 |         switch self {
20 |         case .red:
21 |             return "red"
22 |         case .green:
23 |             return "green"
24 |         case .blue:
25 |             return "blue"
26 |         }
27 |     }
28 | }
29 | 
30 | extension NSAttributedString {
31 | 
32 |     fileprivate func verifyColor(_ color: String, in range: NSRange) {
33 |         verifyAttributes(in: range) { (attributes, foundRange) in
34 |             XCTAssertNotNil(attributes[.test_foregroundColor])
35 |             let foundColor = attributes[.test_foregroundColor] as? String
36 |             XCTAssertEqual(foundColor, color)
37 |             XCTAssertEqual(foundRange, range)
38 |         }
39 |     }
40 | 
41 |     fileprivate func verifyColor(_ color: String) {
42 |         verifyColor(color, in: fullRange)
43 |     }
44 | }
45 | 
46 | final class AttributedStringStylerTests: XCTestCase {
47 | 
48 |     private var styler: AttributedStringStyler<Style>!
49 | 
50 |     override func setUp() {
51 |         super.setUp()
52 |         styler = AttributedStringStyler<Style>()
53 |         Style.allCases.forEach {
54 |             styler.register(attributes: [.test_foregroundColor: $0.color], forStyle: $0)
55 |         }
56 |     }
57 | 
58 |     func testReplaceOneStyle() {
59 |         // Given
60 |         let builder = AttributedStringBuilder<Style>(string: "Red")
61 |         builder.setStyle(.red)
62 |         let input = builder.build()
63 | 
64 |         // When
65 |         let result = input.styled(with: styler)
66 | 
67 |         // Then
68 |         result.verifyColor("red")
69 |     }
70 | 
71 |     func testReplaceMultipleColors() {
72 |         // Given
73 |         let string = Style.allCases.map { $0.rawValue }.joined(separator: " ")
74 |         let builder = AttributedStringBuilder<Style>(string: string)
75 |         for style in Style.allCases {
76 |             let styleRange = NSString(string: string).range(of: style.rawValue)
77 |             builder.setStyle(style, range: styleRange)
78 |         }
79 |         let input = builder.build()
80 | 
81 |         // When
82 |         let result = input.styled(with: styler)
83 | 
84 |         // Then
85 |         for style in Style.allCases {
86 |             let styleRange = NSString(string: string).range(of: style.rawValue)
87 |             result.verifyColor(style.color, in: styleRange)
88 |         }
89 |     }
90 | 
91 |     static var allTests = [
92 |         ("testReplaceOneStyle", testReplaceOneStyle),
93 |         ("testReplaceMultipleColors", testReplaceMultipleColors)
94 |     ]
95 | }
96 | 


--------------------------------------------------------------------------------
/Tests/AttributedStringStyleTests/TestUtils.swift:
--------------------------------------------------------------------------------
 1 | //
 2 | //  TestUtils.swift
 3 | //  AttributedStringStyle
 4 | //
 5 | //  Created by Pierre Felgines on 10/12/2019.
 6 | //
 7 | 
 8 | import Foundation
 9 | import XCTest
10 | 
11 | extension NSAttributedString.Key {
12 |     static let test_foregroundColor = NSAttributedString.Key(rawValue: "test_foregroundColor")
13 | }
14 | 
15 | extension NSAttributedString {
16 | 
17 |     func verifyAttributes(in range: NSRange,
18 |                           verify: ([NSAttributedString.Key: Any], NSRange) -> Void) {
19 |         let totalRange = NSRange(location: 0, length: self.length)
20 |         var foundRange = NSRange(location: 0, length: 1)
21 |         let attributes = self.attributes(
22 |             at: range.location,
23 |             longestEffectiveRange: &foundRange,
24 |             in: totalRange
25 |         )
26 |         verify(attributes, foundRange)
27 |     }
28 | 
29 |     var fullRange: NSRange {
30 |         return NSRange(location: 0, length: self.length)
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/Tests/AttributedStringStyleTests/XCTestManifests.swift:
--------------------------------------------------------------------------------
 1 | import XCTest
 2 | 
 3 | #if !canImport(ObjectiveC)
 4 | public func allTests() -> [XCTestCaseEntry] {
 5 |     return [
 6 |         testCase(AttributedStringStylerTests.allTests),
 7 |         testCase(AttributedStringBuilderTests.allTests)
 8 |     ]
 9 | }
10 | #endif
11 | 


--------------------------------------------------------------------------------
/Tests/LinuxMain.swift:
--------------------------------------------------------------------------------
1 | import XCTest
2 | 
3 | import AttributedStringStyleTests
4 | 
5 | var tests = [XCTestCaseEntry]()
6 | tests += AttributedStringStyleTests.allTests()
7 | XCTMain(tests)
8 | 


--------------------------------------------------------------------------------