fix: swiftlint fixes

drmohundro · Aug 16, 2024 · 4a8eda9 · 4a8eda9
1 parent ab54cd5
commit 4a8eda9
Show file tree

Hide file tree

Showing 14 changed files with 232 additions and 123 deletions.
diff --git a/.swiftlint.yml b/.swiftlint.yml
@@ -3,7 +3,6 @@ included:
   - Tests
   - ./Package.swift
 opt_in_rules:
-  - anyobject_protocol
   - array_init
   - attributes
   - closure_end_indentation

diff --git a/Package.swift b/Package.swift
@@ -36,7 +36,7 @@ let package = Package(
         )
     ],
     dependencies: [
-        .package(url: "https://github.com/apple/swift-testing.git", from: "0.10.0"),
+        .package(url: "https://github.com/apple/swift-testing.git", from: "0.10.0")
     ],
     targets: [
         .target(

diff --git a/Tests/SWXMLHashTests/LazyTypesConversionTests.swift b/Tests/SWXMLHashTests/LazyTypesConversionTests.swift
@@ -26,7 +26,8 @@
 import SWXMLHash
 import Testing
 
-@Suite("LazyTypesConversionTests") struct LazyTypesConversionTests {
+@Suite("LazyTypesConversionTests")
+struct LazyTypesConversionTests {
     var parser: XMLIndexer?
     let xmlWithBasicTypes = """
         <root>
@@ -49,7 +50,8 @@ import Testing
         parser = XMLHash.config { cfg in cfg.shouldProcessLazily = true }.parse(xmlWithBasicTypes)
     }
 
-    @Test func shouldConvertValueToNonOptional() {
+    @Test
+    func shouldConvertValueToNonOptional() {
         do {
             let value: String = try parser!["root"]["string"].value()
             #expect(value == "the string value")
@@ -58,7 +60,8 @@ import Testing
         }
     }
 
-    @Test func shouldConvertAttributeToNonOptional() {
+    @Test
+    func shouldConvertAttributeToNonOptional() {
         do {
             let value: Int = try parser!["root"]["attribute"].value(ofAttribute: "int")
             #expect(value == 1)
@@ -67,7 +70,8 @@ import Testing
         }
     }
 
-    @Test func shouldBeAbleToGetUserInfoDuringDeserialization() {
+    @Test
+    func shouldBeAbleToGetUserInfoDuringDeserialization() {
         let parser = XMLHash.config { config in
             let options = SampleUserInfo(apiVersion: .v1)
             config.userInfo = [ SampleUserInfo.key: options ]

diff --git a/Tests/SWXMLHashTests/LazyWhiteSpaceParsingTests.swift b/Tests/SWXMLHashTests/LazyWhiteSpaceParsingTests.swift
@@ -35,23 +35,28 @@ struct LazyWhiteSpaceParsingTests {
     init() {
         // Put setup code here. This method is called before the invocation of each test method in the class.
 
-#if SWIFT_PACKAGE
+// #if SWIFT_PACKAGE
+//         let path = URL(fileURLWithPath: #file).deletingLastPathComponent().appendingPathComponent("test.xml").path
+// #else
+//         let bundle = Bundle(for: WhiteSpaceParsingTests.self)
+//         let path = bundle.path(forResource: "test", ofType: "xml")!
+// #endif
+
         let path = URL(fileURLWithPath: #file).deletingLastPathComponent().appendingPathComponent("test.xml").path
-#else
-        let bundle = Bundle(for: WhiteSpaceParsingTests.self)
-        let path = bundle.path(forResource: "test", ofType: "xml")!
-#endif
+
         // swiftlint:disable:next force_try
         let data = try! Data(contentsOf: URL(fileURLWithPath: path))
         xml = XMLHash.lazy(data)
     }
 
     // issue #6
-    @Test func shouldBeAbleToPullTextBetweenElementsWithoutWhitespace() {
+    @Test
+    func shouldBeAbleToPullTextBetweenElementsWithoutWhitespace() {
         #expect(xml!["niotemplate"]["section"][0]["constraint"][1].element?.text == "H:|-15-[title]-15-|")
     }
 
-    @Test func shouldBeAbleToCorrectlyParseCDATASectionsWithWhitespace() {
+    @Test
+    func shouldBeAbleToCorrectlyParseCDATASectionsWithWhitespace() {
         #expect(xml!["niotemplate"]["other"].element?.text == "\n        \n  this\n  has\n  white\n  space\n        \n    ")
     }
 }

diff --git a/Tests/SWXMLHashTests/LazyXMLParsingTests.swift b/Tests/SWXMLHashTests/LazyXMLParsingTests.swift
@@ -66,24 +66,29 @@ struct LazyXMLParsingTests {
         xml = XMLHash.config { config in config.shouldProcessLazily = true }.parse(xmlToParse)
     }
 
-    @Test func shouldBeAbleToParseIndividualElements() {
+    @Test
+    func shouldBeAbleToParseIndividualElements() {
         #expect(xml!["root"]["header"]["title"].element?.text == "Test Title Header")
     }
 
-    @Test func shouldBeAbleToHandleSubsequentParseCalls() {
+    @Test
+    func shouldBeAbleToHandleSubsequentParseCalls() {
         #expect(xml!["root"]["header"]["title"].element?.text == "Test Title Header")
         #expect(xml!["root"]["catalog"]["book"][1]["author"].element?.text == "Ralls, Kim")
     }
 
-    @Test func shouldBeAbleToParseElementGroups() {
+    @Test
+    func shouldBeAbleToParseElementGroups() {
         #expect(xml!["root"]["catalog"]["book"][1]["author"].element?.text == "Ralls, Kim")
     }
 
-    @Test func shouldBeAbleToParseAttributes() {
+    @Test
+    func shouldBeAbleToParseAttributes() {
         #expect(xml!["root"]["catalog"]["book"][1].element?.attribute(by: "id")?.text == "bk102")
     }
 
-    @Test func shouldBeAbleToLookUpElementsByNameAndAttribute() {
+    @Test
+    func shouldBeAbleToLookUpElementsByNameAndAttribute() {
         do {
             let value = try xml!["root"]["catalog"]["book"].withAttribute("id", "bk102")["author"].element?.text
             #expect(value == "Ralls, Kim")
@@ -92,20 +97,24 @@ struct LazyXMLParsingTests {
         }
     }
 
-    @Test func shouldBeAbleToIterateElementGroups() {
+    @Test
+    func shouldBeAbleToIterateElementGroups() {
         let result = xml!["root"]["catalog"]["book"].all.map({ $0["genre"].element!.text }).joined(separator: ", ")
         #expect(result == "Computer, Fantasy, Fantasy")
     }
 
-    @Test func shouldBeAbleToIterateElementGroupsEvenIfOnlyOneElementIsFound() {
+    @Test
+    func shouldBeAbleToIterateElementGroupsEvenIfOnlyOneElementIsFound() {
         #expect(xml!["root"]["header"]["title"].all.count == 1)
     }
 
-    @Test func shouldBeAbleToIndexElementGroupsEvenIfOnlyOneElementIsFound() {
+    @Test
+    func shouldBeAbleToIndexElementGroupsEvenIfOnlyOneElementIsFound() {
         #expect(xml!["root"]["header"]["title"][0].element?.text == "Test Title Header")
     }
 
-    @Test func shouldBeAbleToIterateUsingForIn() {
+    @Test
+    func shouldBeAbleToIterateUsingForIn() {
         var count = 0
         for _ in xml!["root"]["catalog"]["book"].all {
             count += 1
@@ -114,35 +123,41 @@ struct LazyXMLParsingTests {
         #expect(count == 3)
     }
 
-    @Test func shouldBeAbleToEnumerateChildren() {
+    @Test
+    func shouldBeAbleToEnumerateChildren() {
         let result = xml!["root"]["catalog"]["book"][0].children.map({ $0.element!.name }).joined(separator: ", ")
         #expect(result == "author, title, genre, price, publish_date, description")
     }
 
-    @Test func shouldBeAbleToHandleMixedContent() {
+    @Test
+    func shouldBeAbleToHandleMixedContent() {
         #expect(xml!["root"]["header"].element?.text == "header mixed contentmore mixed content")
     }
 
-    @Test func shouldHandleInterleavingXMLElements() {
+    @Test
+    func shouldHandleInterleavingXMLElements() {
         let interleavedXml = "<html><body><p>one</p><div>two</div><p>three</p><div>four</div></body></html>"
         let parsed = XMLHash.parse(interleavedXml)
 
         let result = parsed["html"]["body"].children.map({ $0.element!.text }).joined(separator: ", ")
         #expect(result == "one, two, three, four")
     }
 
-    @Test func shouldBeAbleToProvideADescriptionForTheDocument() {
+    @Test
+    func shouldBeAbleToProvideADescriptionForTheDocument() {
         let descriptionXml = "<root><foo><what id=\"myId\">puppies</what></foo></root>"
         let parsed = XMLHash.parse(descriptionXml)
 
         #expect(parsed.description == "<root><foo><what id=\"myId\">puppies</what></foo></root>")
     }
 
-    @Test func shouldReturnNilWhenKeysDontMatch() {
+    @Test
+    func shouldReturnNilWhenKeysDontMatch() {
         #expect(xml!["root"]["what"]["header"]["foo"].element?.name == nil)
     }
 
-    @Test func shouldBeAbleToFilterOnIndexer() {
+    @Test
+    func shouldBeAbleToFilterOnIndexer() {
         let subIndexer = xml!["root"]["catalog"]["book"]
             .filterAll { elem, _ in elem.attribute(by: "id")!.text == "bk102" }
             .filterChildren { _, index in index >= 1 && index <= 3 }

diff --git a/Tests/SWXMLHashTests/MixedTextWithXMLElementsTests.swift b/Tests/SWXMLHashTests/MixedTextWithXMLElementsTests.swift
@@ -36,7 +36,8 @@ struct MixedTextWithXMLElementsTests {
         xml = XMLHash.parse(xmlContent)
     }
 
-    @Test func shouldBeAbleToGetAllContentsInsideOfAnElement() {
+    @Test
+    func shouldBeAbleToGetAllContentsInsideOfAnElement() {
         #expect(xml!["everything"]["news"]["content"].description == "<content>Here is a cool thing <a href=\"google.com\">A</a> and second cool thing <a href=\"fb.com\">B</a></content>")
     }
 }

diff --git a/Tests/SWXMLHashTests/TypeConversionArrayOfNonPrimitiveTypesTests.swift b/Tests/SWXMLHashTests/TypeConversionArrayOfNonPrimitiveTypesTests.swift
@@ -90,7 +90,8 @@ struct TypeConversionArrayOfNonPrimitiveTypesTests {
         parser = XMLHash.parse(xmlWithArraysOfTypes)
     }
 
-    @Test func shouldConvertArrayOfGoodBasicItemsToNonOptional() {
+    @Test
+    func shouldConvertArrayOfGoodBasicItemsToNonOptional() {
         do {
             let value: [BasicItem] = try parser!["root"]["arrayOfGoodBasicItems"]["basicItem"].value()
             #expect(value == correctBasicItems)
@@ -99,7 +100,8 @@ struct TypeConversionArrayOfNonPrimitiveTypesTests {
         }
     }
 
-    @Test func shouldConvertArrayOfGoodBasicItemsToOptional() {
+    @Test
+    func shouldConvertArrayOfGoodBasicItemsToOptional() {
         do {
             let value: [BasicItem]? = try parser!["root"]["arrayOfGoodBasicItems"]["basicItem"].value()
             #expect(value != nil)
@@ -111,7 +113,8 @@ struct TypeConversionArrayOfNonPrimitiveTypesTests {
         }
     }
 
-    @Test func shouldConvertArrayOfGoodBasicItemsToArrayOfOptionals() {
+    @Test
+    func shouldConvertArrayOfGoodBasicItemsToArrayOfOptionals() {
         do {
             let value: [BasicItem?] = try parser!["root"]["arrayOfGoodBasicItems"]["basicItem"].value()
             #expect(value.compactMap({ $0 }) == correctBasicItems)
@@ -120,25 +123,29 @@ struct TypeConversionArrayOfNonPrimitiveTypesTests {
         }
     }
 
-    @Test func shouldThrowWhenConvertingArrayOfBadBasicItemsToNonOptional() {
+    @Test
+    func shouldThrowWhenConvertingArrayOfBadBasicItemsToNonOptional() {
         #expect(throws: XMLDeserializationError.self) {
             try (parser!["root"]["arrayOfBadBasicItems"]["basicItem"].value() as [BasicItem])
         }
     }
 
-    @Test func shouldThrowWhenConvertingArrayOfBadBasicItemsToOptional() {
+    @Test
+    func shouldThrowWhenConvertingArrayOfBadBasicItemsToOptional() {
         #expect(throws: XMLDeserializationError.self) {
             try (parser!["root"]["arrayOfBadBasicItems"]["basicItem"].value() as [BasicItem]?)
         }
     }
 
-    @Test func shouldThrowWhenConvertingArrayOfBadBasicItemsToArrayOfOptionals() {
+    @Test
+    func shouldThrowWhenConvertingArrayOfBadBasicItemsToArrayOfOptionals() {
         #expect(throws: XMLDeserializationError.self) {
             try (parser!["root"]["arrayOfBadBasicItems"]["basicItem"].value() as [BasicItem?])
         }
     }
 
-    @Test func shouldConvertArrayOfEmptyMissingToOptional() {
+    @Test
+    func shouldConvertArrayOfEmptyMissingToOptional() {
         do {
             let value: [BasicItem]? = try parser!["root"]["arrayOfMissingBasicItems"]["basicItem"].value()
             #expect(value == nil)
@@ -147,7 +154,8 @@ struct TypeConversionArrayOfNonPrimitiveTypesTests {
         }
     }
 
-    @Test func shouldConvertArrayOfGoodAttributeItemsToNonOptional() {
+    @Test
+    func shouldConvertArrayOfGoodAttributeItemsToNonOptional() {
         do {
             let value: [AttributeItem] = try parser!["root"]["arrayOfGoodAttributeItems"]["attributeItem"].value()
             #expect(value == correctAttributeItems)
@@ -156,7 +164,8 @@ struct TypeConversionArrayOfNonPrimitiveTypesTests {
         }
     }
 
-    @Test func shouldConvertArrayOfGoodAttributeItemsToOptional() {
+    @Test
+    func shouldConvertArrayOfGoodAttributeItemsToOptional() {
         do {
             let value: [AttributeItem]? = try parser!["root"]["arrayOfGoodAttributeItems"]["attributeItem"].value()
             #expect(value != nil)
@@ -168,7 +177,8 @@ struct TypeConversionArrayOfNonPrimitiveTypesTests {
         }
     }
 
-    @Test func shouldConvertArrayOfGoodAttributeItemsToArrayOfOptionals() {
+    @Test
+    func shouldConvertArrayOfGoodAttributeItemsToArrayOfOptionals() {
         do {
             let value: [AttributeItem?] = try parser!["root"]["arrayOfGoodAttributeItems"]["attributeItem"].value()
             #expect(value.compactMap({ $0 }) == correctAttributeItems)
@@ -177,19 +187,22 @@ struct TypeConversionArrayOfNonPrimitiveTypesTests {
         }
     }
 
-    @Test func shouldThrowWhenConvertingArrayOfBadAttributeItemsToNonOptional() {
+    @Test
+    func shouldThrowWhenConvertingArrayOfBadAttributeItemsToNonOptional() {
         #expect(throws: XMLDeserializationError.self) {
             try (parser!["root"]["arrayOfBadAttributeItems"]["attributeItem"].value() as [AttributeItem])
         }
     }
 
-    @Test func shouldThrowWhenConvertingArrayOfBadAttributeItemsToOptional() {
+    @Test
+    func shouldThrowWhenConvertingArrayOfBadAttributeItemsToOptional() {
         #expect(throws: XMLDeserializationError.self) {
             try (parser!["root"]["arrayOfBadAttributeItems"]["attributeItem"].value() as [AttributeItem]?)
         }
     }
 
-    @Test func shouldThrowWhenConvertingArrayOfBadAttributeItemsToArrayOfOptionals() {
+    @Test
+    func shouldThrowWhenConvertingArrayOfBadAttributeItemsToArrayOfOptionals() {
         #expect(throws: XMLDeserializationError.self) {
             try (parser!["root"]["arrayOfBadAttributeItems"]["attributeItem"].value() as [AttributeItem?])
         }