introduce aging strategies. Parametrize rules

Java/src/main/java/com/gildedrose/GildedRose.java

@@ -1,31 +1,46 @@
 package com.gildedrose;
 
 import com.gildedrose.rules.AgedBrieQualityRule;
+import com.gildedrose.rules.AgingStrategy;
 import com.gildedrose.rules.BackstagePassQualityRule;
 import com.gildedrose.rules.ConjuredQualityRule;
+import com.gildedrose.rules.ConstantQualityRule;
+import com.gildedrose.rules.DefaultAgingStrategy;
 import com.gildedrose.rules.DefaultQualityRule;
+import com.gildedrose.rules.NoAgingStrategy;
 import com.gildedrose.rules.QualityRule;
 import com.gildedrose.rules.Result;
-import com.gildedrose.rules.SulfurasQualityRule;
 
 import java.util.Arrays;
 import java.util.List;
+import java.util.Map;
 
 class GildedRose {
-    Item[] items;
+
+    @SuppressWarnings("SpellCheckingInspection")
+    private static final String SULFURAS_HAND_OF_RAGNAROS = "Sulfuras, Hand of Ragnaros";
+
+    final Item[] items;
 
     private final List<QualityRule> rules = List.of(
-            new SulfurasQualityRule(),
+            new ConstantQualityRule(SULFURAS_HAND_OF_RAGNAROS),
             new AgedBrieQualityRule(),
             new BackstagePassQualityRule(),
             new ConjuredQualityRule(),
             new DefaultQualityRule()
     );
 
+    private final DefaultAgingStrategy defaultAgingStrategy = new DefaultAgingStrategy();
+    private final Map<String, AgingStrategy> nameToAgingStrategyMap = Map.of(
+            SULFURAS_HAND_OF_RAGNAROS, new NoAgingStrategy()
+    );
+
+    @SuppressWarnings("WeakerAccess")
     public GildedRose(Item[] items) {
         this.items = items;
     }
 
+    @SuppressWarnings("WeakerAccess")
     public void updateQuality() {
         Arrays.stream(items)
                 .parallel()
@@ -33,28 +48,27 @@ class GildedRose {
     }
 
     private void processItem(final Item item) {
-
         item.sellIn = calculateSellIn(item.name, item.sellIn);
 
-        item.quality = rules.stream()
+        item.quality = calculateQuality(item.name, item.quality, item.sellIn);
-                .reduce(new Result(item.quality, false),
-                        (q, rule) -> {
-                            if (q.isFinalValue() || !rule.shouldApply(item.name)) {
-                                return q;
-                            } else {
-                                return rule.calculateQuality(q.getQuality(), item.sellIn);
-                            }
-                        },
-                        (a, b) -> b).getQuality();
-
     }
 
     private int calculateSellIn(final String name, final int originalSellIn) {
-        if ("Sulfuras, Hand of Ragnaros".equals(name)) {
+        return nameToAgingStrategyMap
-            return originalSellIn;
+                .getOrDefault(name, defaultAgingStrategy)
-        } else {
+                .calculateSellIn(originalSellIn);
-            return originalSellIn - 1;
+    }
-        }
 
+    private int calculateQuality(String itemName, int quality, int newSellIn) {
+        return rules.stream()
+                .reduce(new Result(quality, false),
+                        (q, rule) -> {
+                            if (q.isFinalValue() || !rule.shouldApply(itemName)) {
+                                return q;
+                            } else {
+                                return rule.calculateQuality(q.getQuality(), newSellIn);
+                            }
+                        },
+                        (a, b) -> b).getQuality();
     }
 }

Java/src/main/java/com/gildedrose/rules/AgingStrategy.java

@@ -0,0 +1,6 @@
+package com.gildedrose.rules;
+
+public interface AgingStrategy {
+
+    int calculateSellIn(int oldSellIn);
+}

Java/src/main/java/com/gildedrose/rules/ConstantQualityRule.java

@@ -0,0 +1,22 @@
+package com.gildedrose.rules;
+
+import java.util.Objects;
+
+public class ConstantQualityRule implements QualityRule {
+
+    private final String expectedName;
+
+    public ConstantQualityRule(String itemName) {
+        this.expectedName = Objects.requireNonNull(itemName, "ItemName is required");
+    }
+
+    @Override
+    public boolean shouldApply(String itemName) {
+        return expectedName.equals(itemName);
+    }
+
+    @Override
+    public Result calculateQuality(int oldQuality, int newSellIn) {
+        return new Result(oldQuality, true);
+    }
+}

Java/src/main/java/com/gildedrose/rules/DefaultAgingStrategy.java

@@ -0,0 +1,8 @@
+package com.gildedrose.rules;
+
+public class DefaultAgingStrategy implements AgingStrategy {
+    @Override
+    public int calculateSellIn(int oldSellIn) {
+        return oldSellIn - 1;
+    }
+}

Java/src/main/java/com/gildedrose/rules/NoAgingStrategy.java

@@ -0,0 +1,9 @@
+package com.gildedrose.rules;
+
+public class NoAgingStrategy implements AgingStrategy {
+
+    @Override
+    public int calculateSellIn(int oldSellIn) {
+        return oldSellIn;
+    }
+}

Java/src/main/java/com/gildedrose/rules/SellInRule.java

@@ -0,0 +1,8 @@
+package com.gildedrose.rules;
+
+public interface SellInRule {
+
+    boolean shouldApply(String itemName);
+
+    Result calculateQuality(int oldQuality, int newSellIn);
+}

Java/src/main/java/com/gildedrose/rules/SulfurasQualityRule.java

@@ -1,14 +0,0 @@
-package com.gildedrose.rules;
-
-public class SulfurasQualityRule implements QualityRule {
-
-    @Override
-    public boolean shouldApply(String itemName) {
-        return "Sulfuras, Hand of Ragnaros".equals(itemName);
-    }
-
-    @Override
-    public Result calculateQuality(int oldQuality, int newSellIn) {
-        return new Result(oldQuality, true);
-    }
-}