Refactor: Some module was improve

app/src/main/java/hexlet/code/schemas/BaseSchema.java

@@ -1,17 +1,31 @@
 package hexlet.code.schemas;
 
-import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.Map;
+import java.util.Objects;
 import java.util.function.Predicate;
 
 public abstract class BaseSchema<T> {
+    boolean isRequired = false;
+    private Map<String, Predicate<T>> conditions = new LinkedHashMap<>();
+
+    BaseSchema() {
+        setConditions("isValueNull", Objects::nonNull);
+    }
+
     public final void setConditions(String key, Predicate<T> value) {
         this.conditions.put(key, value);
     }
 
-    private Map<String, Predicate<T>> conditions = new HashMap<>();
-
     public final boolean isValid(T value) {
+
+        if (!isRequired) {
+            var checkNull = conditions.get("isValueNull");
+            if (!checkNull.test(value)) {
+                return true;
+            }
+        }
+
         for (String r : conditions.keySet()) {
             if (!conditions.get(r).test(value)) {
                 return false;

app/src/main/java/hexlet/code/schemas/MapSchema.java

@@ -4,8 +4,8 @@
 
 public class MapSchema extends BaseSchema<Map<String, ?>> {
 
-
     public final MapSchema required() {
+        super.isRequired = true;
         setConditions("required", inspectedMap -> inspectedMap != null);
         return this;
     }
@@ -16,10 +16,13 @@ public final MapSchema sizeof(int mapLimit) {
     }
 
     public final <T> MapSchema shape(Map<String, BaseSchema<T>> schemas) {
-        for (String key : schemas.keySet()) {
-            BaseSchema<T> schemaForField = schemas.get(key);
-            setConditions(key, inspectedMap -> schemaForField.isValid((T) inspectedMap.get(key)));
-        }
+        setConditions("shape", map -> {
+            return schemas.entrySet().stream().allMatch(e -> {
+                var v = map.get(e.getKey());
+                var schema = e.getValue();
+                return schema.isValid((T) v);
+            });
+        });
         return this;
     }
 }

app/src/main/java/hexlet/code/schemas/NumberSchema.java

@@ -3,17 +3,17 @@
 public class NumberSchema extends BaseSchema<Integer> {
 
     public final NumberSchema required() {
-        setConditions("required", value -> value != null);
+        super.isRequired = true;
         return this;
     }
 
     public final NumberSchema positive() {
-        setConditions("positive", value -> value == null || value > 0);
+        setConditions("positive", value -> value > 0);
         return this;
     }
 
     public final NumberSchema range(int min, int max) {
-        setConditions("range", value -> value == null || value >= min && value <= max);
+        setConditions("range", value -> value >= min && value <= max);
         return this;
     }
 }

app/src/main/java/hexlet/code/schemas/StringSchema.java

@@ -1,23 +1,20 @@
 package hexlet.code.schemas;
 
 public class StringSchema extends BaseSchema<String> {
-    private int minLength;
-    private String subStringContains;
 
     public final StringSchema required() {
-        setConditions("required", value -> value != null && !value.isEmpty());
+        super.isRequired = true;
+        setConditions("required", value -> !value.isEmpty());
         return this;
     }
 
-    public final StringSchema minLength(int length) {
-        this.minLength = length;
-        setConditions("minLength", value -> value == null || value.length() >= minLength);
+    public final StringSchema minLength(int minLength) {
+        setConditions("minLength", value -> value.length() >= minLength);
         return this;
     }
 
     public final StringSchema contains(String substring) {
-        this.subStringContains = substring;
-        setConditions("contains", value -> value == null || value.contains(subStringContains));
+        setConditions("contains", value -> value.contains(substring));
         return this;
     }
 }