Added rules for conjured items

swift/Sources/GildedRose/Rules/QualityModificationRules.swift

@@ -13,10 +13,15 @@ enum QualityModificationRule: Rule {
 
     case regular,
          increasesQuality,
+         conjured,
          qualityIncreasesFasterBeforeExpireThenDropsToZero,
          legendary
 
     static func rule(for item: Item) -> RuleType {
+        if item.name.lowercased().contains("conjured") {
+            return .conjured
+        }
+
         switch item.name {
         case "Aged Brie":
             return .increasesQuality
@@ -30,65 +35,71 @@ enum QualityModificationRule: Rule {
     }
 
     func apply(to item: Item) -> Item {
+        let newQuality: Int
         switch self {
         case .regular:
-            return applyRegularRule(to: item)
+            newQuality = regularRuleQuality(for: item)
         case .increasesQuality:
-            return applyIncreasesQualityRule(to: item)
+            newQuality = increasesQualityQuality(for: item)
         case .qualityIncreasesFasterBeforeExpireThenDropsToZero:
-            return qualityIncreasesFasterBeforeExpireThenDropsToZeroRule(to: item)
+            newQuality = increasesFasterBeforeExpireThenDropsToZeroQuality(for: item)
         case .legendary:
-            return applyLegendaryRule(to: item)
+            return item // Unmodified
+        case .conjured:
+            newQuality = conjuredRuleQuality(for: item)
         }
+
+        return Self.modify(item: item, with: newQuality)
     }
 
-    private func applyRegularRule(to item: Item) -> Item {
+    private func regularRuleQuality(for item: Item) -> Int {
         let modification = Self.isRegularItemExpired(sellIn: item.sellIn) ? -2 : -1
-        return Self.applyQualityThresholds(to: item, newQuality: item.quality + modification)
+        return item.quality + modification
     }
 
-    private func applyIncreasesQualityRule(to item: Item) -> Item {
+    private func increasesQualityQuality(for item: Item) -> Int {
-        Self.applyQualityThresholds(to: item, newQuality: item.quality + 1)
+        return item.quality + 1
     }
 
-    private func qualityIncreasesFasterBeforeExpireThenDropsToZeroRule(to item: Item) -> Item {
+    private func increasesFasterBeforeExpireThenDropsToZeroQuality(for item: Item) -> Int {
-        let newQuality: Int
         switch item.sellIn {
         case ...0:
-            newQuality = 0
+            return 0
         case 0...5:
-            newQuality = item.quality + 3
+            return item.quality + 3
         case 5...10:
-            newQuality = item.quality + 2
+            return item.quality + 2
         case 10...:
-            newQuality = item.quality + 1
+            return item.quality + 1
         default:
             fatalError("All values of `sellIn` should be covered")
         }
-
-        return Self.applyQualityThresholds(to: item, newQuality: newQuality)
     }
 
-    private func applyLegendaryRule(to item: Item) -> Item {
+    private func conjuredRuleQuality(for item: Item) -> Int {
-        return item // No change
+        let modification = Self.isRegularItemExpired(sellIn: item.sellIn) ? -4 : -2
+        return item.quality + modification
     }
 
-    public static func applyQualityThresholds(to item: Item, newQuality: Int) -> Item {
+    public static func modify(item: Item, with newQuality: Int) -> Item {
-        let correctedQuality: Int
+        let correctedQuality = applyQualityThresholds(to: newQuality)
-        switch newQuality {
-        case ...0:
-            correctedQuality = 0
-        case 0...50:
-            correctedQuality = newQuality
-        case 50...:
-            correctedQuality = 50
-        default:
-            fatalError("All values of `quality` should be covered")
-        }
 
         return Item(name: item.name, sellIn: item.sellIn, quality: correctedQuality)
     }
 
+    public static func applyQualityThresholds(to quality: Int) -> Int {
+        switch quality {
+            case ...0:
+                return 0
+            case 0...50:
+                return quality
+            case 50...:
+                return 50
+            default:
+                fatalError("All values of `quality` should be covered")
+        }
+    }
+
     public static func isRegularItemExpired(sellIn: Int) -> Bool {
         return sellIn <= 0
     }

swift/Tests/GildedRoseTests/TestQualityModificationRules.swift

@@ -23,13 +23,9 @@ class TestSellInModificationRule: XCTestCase {
     }
 
     func testApplyQualityThresholds() {
-        let tooLow = Item(name: "Too low", sellIn: 0, quality: 0)
+        XCTAssertEqual(QualityModificationRule .applyQualityThresholds(to: -1), 0)
-        let tooHigh = Item(name: "Too high", sellIn: 0, quality: 50)
+        XCTAssertEqual(QualityModificationRule.applyQualityThresholds(to: 51), 50)
-        let unaltered = Item(name: "Too low", sellIn: 0, quality: 25)
+        XCTAssertEqual(QualityModificationRule.applyQualityThresholds(to: 24), 24)
-
-        XCTAssertEqual(QualityModificationRule.applyQualityThresholds(to: tooLow, newQuality: -1).quality, 0)
-        XCTAssertEqual(QualityModificationRule.applyQualityThresholds(to: tooHigh, newQuality: 51).quality, 50)
-        XCTAssertEqual(QualityModificationRule.applyQualityThresholds(to: unaltered, newQuality: 24).quality, 24)
     }
 
     func testIsRegularItemExpired() {