Merge pull request #9 from litso/circle-ci

litso · web-flow · commit 9d48e2858bd0 · 2022-05-02T14:59:45.000-07:00
Add basic CI
diff --git a/.circleci/config.yml b/.circleci/config.yml
@@ -0,0 +1,28 @@
+version: 2.1
+jobs:
+  danger:
+    macos:
+      xcode: 13.2.1
+    working_directory: /Users/distiller/project
+    shell: /bin/bash --login -o pipefail
+    steps:
+      - checkout
+      - run: brew install mint
+      - run: mint bootstrap --link
+      - run:
+          name: Setup Environment Variables
+          command: |
+            echo 'export PATH=$HOME/.mint/bin:$PATH' >> $BASH_ENV
+      - run: swiftlint version
+      - run: brew tap danger/tap
+      - run: brew install danger/tap/danger-swift
+      - run:
+          name: Danger
+          command: danger-swift ci
+
+workflows:
+  version: 2
+  build-test-lint:
+    jobs:
+      - danger
+
diff --git a/.swiftlint.yml b/.swiftlint.yml
@@ -0,0 +1,32 @@
+disabled_rules: # rule identifiers to exclude from running
+  - todo
+  - line_length
+  - large_tuple
+opt_in_rules:
+  - force_unwrapping
+file_length:
+  warning: 600
+identifier_name:
+  min_length: # only min_length
+    error: 2 # only error
+  excluded: # excluded via string array
+    - id
+    - f
+    - s
+    - i
+    - j
+    - x
+    - y
+    - vc
+    - to
+function_body_length:
+  - 60
+  - 60
+nesting:
+  type_level:
+    warning: 2
+private_over_fileprivate:
+    validate_extensions: true
+
+excluded:
+  - Example/Pods
diff --git a/Dangerfile.swift b/Dangerfile.swift
@@ -0,0 +1,111 @@
+import Foundation
+import Danger
+
+// MARK: Helper methods
+
+func validateTitleAllowsMerging(for pullRequest: GitHub.PullRequest) throws {
+    let range = NSRange(pullRequest.title.startIndex..., in: pullRequest.title)
+
+    let wipRegex = try NSRegularExpression(pattern: "\\bWIP\\b", options: .caseInsensitive)
+    if wipRegex.firstMatch(in: pullRequest.title, range: range) != nil {
+        print("Pull request title contains “WIP”.")
+    }
+
+    let doNotMergeRegex = try NSRegularExpression(pattern: "\\bdo not merge\\b", options: .caseInsensitive)
+    if doNotMergeRegex.firstMatch(in: pullRequest.title, range: range) != nil {
+        print("Pull request title contains “do not merge”.")
+    }
+}
+
+func validateMessage(for ghCommit: GitHub.Commit, doesNotHavePrefixes prefixes: [String]) {
+    let commitMessage = ghCommit.commit.message.lowercased()
+    for prefix in prefixes where commitMessage.hasPrefix(prefix.lowercased()) {
+        fail("Commit message \(ghCommit.sha) begins with `\(prefix)`. Squash before merging.")
+    }
+}
+
+func validateSwiftLintRuleChanges(for git: Git) {
+    let hasLintConfigChanges = git.modifiedFiles.contains(".swiftlint.yml")
+    let hasCustomRuleChanges = git.modifiedFiles.contains("SwiftLint/customrules.yml")
+
+    if hasLintConfigChanges, !hasCustomRuleChanges {
+        warn("You updated the SwiftLint config. Do you also need to add a new rule to `customrules.yml`?")
+    } else if !hasLintConfigChanges, hasCustomRuleChanges {
+        warn("You added a new custom SwiftLint rule, don't forget to add it to DressCode's `.swiftlint.yml`!")
+    }
+}
+
+func messageIsGenerated(for ghCommit: GitHub.Commit) -> Bool {
+    guard let firstWord = ghCommit.commit.message.components(separatedBy: " ").first else {
+        return false
+    }
+    return firstWord == "Merge" || firstWord == "Revert" || firstWord == "fixup!" || firstWord == "squash!"
+}
+
+/// Fails if the commit’s message does not satisfy Chris Beams’s
+/// [“The seven rules of a great Git commit message”](https://chris.beams.io/posts/git-commit/).
+func validateMessageIsGreat(for ghCommit: GitHub.Commit) {
+    guard !messageIsGenerated(for: ghCommit) else { return }
+
+    let messageComponents = ghCommit.commit.message.components(separatedBy: "\n")
+    let title = messageComponents[0]
+
+    // Rule 1
+    if messageComponents.count > 1 {
+        let separator = messageComponents[1]
+        if !separator.isEmpty {
+            fail("Commit message \(ghCommit.sha) is missing a blank line between title and body.")
+        }
+    }
+
+    // Rule 2
+    if title.count > 50 {
+        fail("Commit title \(ghCommit.sha) is \(title.count) characters long (title should be limited to 50 characters).")
+    }
+
+    // Rule 3
+    if title.first != title.capitalized.first {
+        fail("Commit title \(ghCommit.sha) is not capitalized.")
+    }
+
+    // Rule 4
+    if title.hasSuffix(".") {
+        fail("Commit title \(ghCommit.sha) ends with a period.")
+    }
+
+    // Rule 5
+    // Use the imperative mood in the subject line
+    // Not validated here
+
+    // Rule 6
+    let body = messageComponents.dropFirst()
+    let lineNumbers = body.indices.map({ $0 + 1 })
+    for (lineNumber, line) in zip(lineNumbers, body) where line.count > 72 {
+        fail("Commit message \(ghCommit.sha) line \(lineNumber) is \(line.count) characters long (body should be wrapped at 72 characters).")
+    }
+
+    // Rule 7
+    // Use the body to explain what and why vs. how
+    // Not validated here
+}
+
+// MARK: - Validations
+
+let danger = Danger()
+let pullRequest = danger.github.pullRequest
+
+try validateTitleAllowsMerging(for: pullRequest)
+
+validateSwiftLintRuleChanges(for: danger.git)
+
+let unmergeablePrefixes = ["fixup!", "squash!", "WIP"]
+danger.github.commits.forEach {
+    validateMessage(for: $0, doesNotHavePrefixes: unmergeablePrefixes)
+    validateMessageIsGreat(for: $0)
+}
+
+if let additions = pullRequest.additions, let deletions = pullRequest.deletions, additions < deletions {
+    message("🎉 This PR removes more code than it adds! (\(additions - deletions) net lines)")
+}
+
+SwiftLint.lint(inline: true, configFile: ".swiftlint.yml")
diff --git a/Mintfile b/Mintfile
@@ -0,0 +1,2 @@
+realm/SwiftLint@0.43.1
+
diff --git a/Sources/Sections/Classes/Sections.swift b/Sources/Sections/Classes/Sections.swift
@@ -39,8 +39,8 @@ extension Sections: Sequence {
     public typealias Iterator = AnyIterator<Section<T>>
 
     public func makeIterator() -> Sections.Iterator {
-        let g = sections.makeIterator()
-        return AnyIterator(g)
+        let iterator = sections.makeIterator()
+        return AnyIterator(iterator)
     }
 }
 
@@ -81,7 +81,7 @@ extension Sections: RangeReplaceableCollection {
         self.sections = []
     }
 
-    public mutating func replaceSubrange<C : Collection>(_ subRange: Range<Sections.Index>, with newElements: C) where C.Iterator.Element == Iterator.Element {
+    public mutating func replaceSubrange<C: Collection>(_ subRange: Range<Sections.Index>, with newElements: C) where C.Iterator.Element == Iterator.Element {
         self.sections.replaceSubrange(subRange, with: newElements)
     }
 }
diff --git a/Tests/SectionsTests/EquatableTests.swift b/Tests/SectionsTests/EquatableTests.swift
@@ -26,57 +26,54 @@ class EquatableTests: XCTestCase {
      Test indexPathOfValue
      */
     func testIndexPathOfValue() {
-        let a = EquatableType(val: "First Value")
-        let b = EquatableType(val: "Second Value")
-        let c = EquatableType(val: "Third Value")
+        let rowA = EquatableType(val: "First Value")
+        let rowB = EquatableType(val: "Second Value")
+        let rowC = EquatableType(val: "Third Value")
 
-        let values = [ a, b, c]
-
-        let sections = SectionBuilder<EquatableType>(initialValues: []).addSections { _ in
-            return [Section(name: "First Section", rows: [values[0]])]
+        let sections = SectionBuilder<EquatableType>(initialValues: [])
+            .addSections { _ in
+                return [Section(name: "First Section", rows: [rowA])]
             }.addSections { _ in
-                return [Section(name: "Second Section", rows: [values[1], values[2]])]
-        }
+                return [Section(name: "Second Section", rows: [rowB, rowC])]
+            }
 
         XCTAssert(sections.sections.count == 2)
 
         XCTAssert(sections.sections[0].name == "First Section")
-        XCTAssert(sections.sections[0].rows[0] == a)
+        XCTAssert(sections.sections[0].rows[0] == rowA)
         XCTAssert(sections.sections[0].rows.count == 1)
 
         XCTAssert(sections.sections[1].rows.count == 2)
         XCTAssert(sections.sections[1].name == "Second Section")
-        XCTAssert(sections.sections[1].rows[0] == b)
-        XCTAssert(sections.sections[1].rows[1] == c)
+        XCTAssert(sections.sections[1].rows[0] == rowB)
+        XCTAssert(sections.sections[1].rows[1] == rowC)
 
-
-        XCTAssert(sections.indexPathOfValue(a) == IndexPath(item: 0, section: 0))
-        XCTAssert(sections.indexPathOfValue(b) == IndexPath(item: 0, section: 1))
-        XCTAssert(sections.indexPathOfValue(c) == IndexPath(item: 1, section: 1))
+        XCTAssert(sections.indexPathOfValue(rowA) == IndexPath(item: 0, section: 0))
+        XCTAssert(sections.indexPathOfValue(rowB) == IndexPath(item: 0, section: 1))
+        XCTAssert(sections.indexPathOfValue(rowC) == IndexPath(item: 1, section: 1))
     }
 
     func testSectionIndexable() {
         func testIndexPathOfValue() {
-            let a = EquatableType(val: "First Value")
-            let b = EquatableType(val: "Second Value")
-            let c = EquatableType(val: "Third Value")
-
-            let values = [ a, b, c]
+            let rowA = EquatableType(val: "First Value")
+            let rowB = EquatableType(val: "Second Value")
+            let rowC = EquatableType(val: "Third Value")
 
-            let sectionBuilder = SectionBuilder<EquatableType>(initialValues: []).addSections { _ in
-                return [Section(name: "First Section", rows: [values[0]])]
+            let sectionBuilder = SectionBuilder<EquatableType>(initialValues: [])
+                .addSections { _ in
+                    return [Section(name: "First Section", rows: [rowA])]
                 }.addSections { _ in
-                    return [Section(name: "Second Section", rows: [values[1], values[2]])]
-            }
+                    return [Section(name: "Second Section", rows: [rowB, rowC])]
+                }
 
             let sections = sectionBuilder.sections
 
             XCTAssert(sectionBuilder.sections.count == 2)
-            XCTAssert(sectionBuilder.sections[0].rows[0] == a)
-            XCTAssert(sectionBuilder.sections[1].rows[1] == c)
+            XCTAssert(sectionBuilder.sections[0].rows[0] == rowA)
+            XCTAssert(sectionBuilder.sections[1].rows[1] == rowC)
 
-            XCTAssert(sections.indexPathForRow(a) == IndexPath(item: 0, section: 0))
-            XCTAssert(sections.indexPathForRow(a) == IndexPath(item: 1, section: 1))
+            XCTAssert(sections.indexPathForRow(rowA) == IndexPath(item: 0, section: 0))
+            XCTAssert(sections.indexPathForRow(rowA) == IndexPath(item: 1, section: 1))
         }
     }
 }
diff --git a/Tests/SectionsTests/Tests.swift b/Tests/SectionsTests/Tests.swift
@@ -11,60 +11,59 @@ class SectionsTests: XCTestCase {
      Test creating two sections from a homogenious data type.
      */
     func testSections() {
-        let a = MyType(val: "First Value")
-        let b = MyType(val: "Second Value")
+        let rowA = MyType(val: "First Value")
+        let rowB = MyType(val: "Second Value")
 
-        let sections = SectionBuilder<MyType>(initialValues: []).addSections { _ in
-            return [Section<MyType>(name: "First", rows: [a])]
+        let sections = SectionBuilder<MyType>(initialValues: [])
+            .addSections { _ in
+                return [Section<MyType>(name: "First", rows: [rowA])]
             }.addSections { _ in
-                return [Section(name: "Second", rows: [b])]
-        }
+                return [Section(name: "Second", rows: [rowB])]
+            }
 
         XCTAssert(sections.sections.count == 2)
 
         XCTAssert(sections.sections[0].name == "First")
-        XCTAssert(sections.sections[0].rows[0] == a)
+        XCTAssert(sections.sections[0].rows[0] == rowA)
         XCTAssert(sections.sections[0].rows.count == 1)
 
         XCTAssert(sections.sections[1].name == "Second")
-        XCTAssert(sections.sections[1].rows[0] == b)
+        XCTAssert(sections.sections[1].rows[0] == rowB)
         XCTAssert(sections.sections[1].rows.count == 1)
     }
 
     /**
-     Test changing the `values` captured by the section build after the capture. Also test returning multiple sections in one closure.
+     Test returning multiple sections in one closure.
      */
     func testSections2() {
-        let a = MyType(val: "First Value")
-        let b = MyType(val: "Second Value")
-        let c = MyType(val: "Third Value")
+        let rowA = MyType(val: "First Value")
+        let rowB = MyType(val: "Second Value")
+        let rowC = MyType(val: "Third Value")
 
-        let values = [a, b, c]
-
-        let sections = SectionBuilder<MyType>(initialValues: []).addSections { _ in
-            return [Section(name: "First", rows: [values[0]])]
+        let sections = SectionBuilder<MyType>(initialValues: [])
+            .addSections { _ in
+                return [Section(name: "First", rows: [rowA])]
             }.addSections { _ in
-                return [Section<MyType>(name: "Second", rows: [values[1]])]
-                    + [Section<MyType>(name: "Third", rows: [values[2]])]
-        }
+                return [Section<MyType>(name: "Second", rows: [rowB])]
+                + [Section<MyType>(name: "Third", rows: [rowC])]
+            }
 
         XCTAssert(sections.sections.count == 3)
 
         XCTAssert(sections.sections[0].name == "First")
-        XCTAssert(sections.sections[0].rows[0] == a)
+        XCTAssert(sections.sections[0].rows[0] == rowA)
         XCTAssert(sections.sections[0].rows.count == 1)
 
         XCTAssert(sections.sections[1].name == "Second")
-        XCTAssert(sections.sections[1].rows[0] == b)
+        XCTAssert(sections.sections[1].rows[0] == rowB)
         XCTAssert(sections.sections[1].rows.count == 1)
 
         XCTAssert(sections.sections[2].name == "Third")
-        XCTAssert(sections.sections[2].rows[0] == c)
+        XCTAssert(sections.sections[2].rows[0] == rowC)
         XCTAssert(sections.sections[2].rows.count == 1)
     }
 }
 
-
 extension SectionsTests.MyType: Equatable {}
 
 func == (lhs: SectionsTests.MyType, rhs: SectionsTests.MyType) -> Bool {

Original file line number	Diff line number	Diff line change
`@@ -39,8 +39,8 @@ extension Sections: Sequence {`
`39`	`39`	`public typealias Iterator = AnyIterator<Section<T>>`
`40`	`40`
`41`	`41`	`public func makeIterator() -> Sections.Iterator {`
`42`		`- let g = sections.makeIterator()`
`43`		`- return AnyIterator(g)`
	`42`	`+ let iterator = sections.makeIterator()`
	`43`	`+ return AnyIterator(iterator)`
`44`	`44`	`}`
`45`	`45`	`}`
`46`	`46`
`@@ -81,7 +81,7 @@ extension Sections: RangeReplaceableCollection {`
`81`	`81`	`self.sections = []`
`82`	`82`	`}`
`83`	`83`
`84`		`- public mutating func replaceSubrange<C : Collection>(_ subRange: Range<Sections.Index>, with newElements: C) where C.Iterator.Element == Iterator.Element {`
	`84`	`+ public mutating func replaceSubrange<C: Collection>(_ subRange: Range<Sections.Index>, with newElements: C) where C.Iterator.Element == Iterator.Element {`
`85`	`85`	`self.sections.replaceSubrange(subRange, with: newElements)`
`86`	`86`	`}`
`87`	`87`	`}`