Merge branch 'read-write-only'

# Conflicts:
#	src/main/java/com/qdesrame/openapi/diff/compare/schemadiffresult/SchemaDiffResult.java
#	src/main/java/com/qdesrame/openapi/diff/output/MarkdownRender.java

Author: quen2404

src/main/java/com/qdesrame/openapi/diff/compare/schemadiffresult/SchemaDiffResult.java

@@ -13,6 +13,7 @@
 import lombok.Getter;
 
 import java.util.*;
+import java.util.stream.Collectors;
 
 import static com.qdesrame.openapi.diff.utils.ChangedUtils.isChanged;
 
@@ -51,8 +52,6 @@ public Optional<ChangedSchema> diff(HashSet<String> refSet, Components leftCompo
         Map<String, Schema> leftProperties = null == left ? null : left.getProperties();
         Map<String, Schema> rightProperties = null == right ? null : right.getProperties();
         MapKeyDiff<String, Schema> propertyDiff = MapKeyDiff.diff(leftProperties, rightProperties);
-        Map<String, Schema> increasedProp = propertyDiff.getIncreased();
-        Map<String, Schema> missingProp = propertyDiff.getMissing();
 
         for (String key : propertyDiff.getSharedKey()) {
             Optional<ChangedSchema> resultSchema = openApiDiff.getSchemaDiff().diff(refSet, leftProperties.get(key), rightProperties.get(key), required(context, key, right.getRequired()));
@@ -61,11 +60,22 @@ public Optional<ChangedSchema> diff(HashSet<String> refSet, Components leftCompo
 
         compareAdditionalProperties(refSet, left, right, context);
 
-        changedSchema.getIncreasedProperties().putAll(increasedProp);
-        changedSchema.getMissingProperties().putAll(missingProp);
+        changedSchema.getIncreasedProperties().putAll(filterProperties(propertyDiff.getIncreased(), context));
+        changedSchema.getMissingProperties().putAll(filterProperties(propertyDiff.getMissing(), context));
         return isChanged(changedSchema);
     }
 
+    private Map<String, Schema> filterProperties(Map<String, Schema> properties, DiffContext context) {
+        return properties.entrySet().stream()
+                .filter(entry -> isPropertyApplicable(entry.getValue(), context))
+                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+    }
+
+    private boolean isPropertyApplicable(Schema schema, DiffContext context) {
+        return !(context.isResponse() && Boolean.TRUE.equals(schema.getWriteOnly()))
+                && !(context.isRequest() && Boolean.TRUE.equals(schema.getReadOnly()));
+    }
+
     private DiffContext required(DiffContext context, String key, List<String> required) {
         return context.copyWithRequired(required != null && required.contains(key));
     }

src/main/java/com/qdesrame/openapi/diff/output/MarkdownRender.java

@@ -203,13 +203,23 @@ protected String oneOfSchema(int deepness, ChangedOneOfSchema schema, String dis
                 .forEach(key -> sb.append(format("%sDeleted '%s' %s\n", indent(deepness), key, discriminator)));
         schema.getIncreasedMapping().forEach((key, sub) ->
                 sb.append(format("%sAdded '%s' %s:\n", indent(deepness), key, discriminator))
-                        .append(schema(deepness, sub)));
+                        .append(schema(deepness, sub, schema.getContext())));
         schema.getChangedMapping().forEach((key, sub) ->
                 sb.append(format("%sUpdated `%s` %s:\n", indent(deepness), key, discriminator))
                         .append(schema(deepness, sub)));
         return sb.toString();
     }
 
+    protected String required(int deepness, String title, List<String> required) {
+        StringBuilder sb = new StringBuilder("");
+        if (required.size() > 0) {
+            sb.append(format("%s%s:\n", indent(deepness), title));
+            required.forEach(s -> sb.append(format("%s- `%s`\n", indent(deepness), s)));
+            sb.append("\n");
+        }
+        return sb.toString();
+    }
+
     protected String schema(int deepness, ChangedSchema schema) {
         StringBuilder sb = new StringBuilder("");
         if (schema.isDiscriminatorPropertyChanged()) {
@@ -220,58 +230,62 @@ protected String schema(int deepness, ChangedSchema schema) {
                     schema.getNewSchema().getDiscriminator().getPropertyName() : "";
             sb.append(oneOfSchema(deepness, schema.getChangedOneOfSchema(), discriminator));
         }
+        if (schema.getChangeRequired() != null) {
+            sb.append(required(deepness, "New required properties", schema.getChangeRequired().getIncreased()));
+            sb.append(required(deepness, "New optional properties", schema.getChangeRequired().getMissing()));
+        }
         sb.append(listDiff(deepness, "enum", schema.getChangeEnum()));
-        sb.append(properties(deepness, "Added property", schema.getIncreasedProperties(), true));
-        sb.append(properties(deepness, "Deleted property", schema.getMissingProperties(), false));
+        sb.append(properties(deepness, "Added property", schema.getIncreasedProperties(), true, schema.getContext()));
+        sb.append(properties(deepness, "Deleted property", schema.getMissingProperties(), false, schema.getContext()));
         schema.getChangedProperties().forEach((name, property) -> sb.append(property(deepness, name, property)));
         return sb.toString();
     }
 
-    protected String schema(int deepness, ComposedSchema schema) {
+    protected String schema(int deepness, ComposedSchema schema, DiffContext context) {
         StringBuilder sb = new StringBuilder("");
         if (schema.getAllOf() != null && schema.getAllOf() != null) {
             LOGGER.debug("All of schema");
             schema.getAllOf().stream()
                     .map(this::resolve)
-                    .forEach(composedChild -> sb.append(schema(deepness, composedChild)));
+                    .forEach(composedChild -> sb.append(schema(deepness, composedChild, context)));
         }
         if (schema.getOneOf() != null && schema.getOneOf() != null) {
             LOGGER.debug("One of schema");
             sb.append(format("%sOne of:\n\n", indent(deepness)));
             schema.getOneOf().stream()
                     .map(this::resolve)
-                    .forEach(composedChild -> sb.append(schema(deepness + 1, composedChild)));
+                    .forEach(composedChild -> sb.append(schema(deepness + 1, composedChild, context)));
         }
         return sb.toString();
     }
 
-    protected String schema(int deepness, Schema schema) {
+    protected String schema(int deepness, Schema schema, DiffContext context) {
         StringBuilder sb = new StringBuilder("");
         sb.append(listItem(deepness, "Enum", schema.getEnum()));
-        sb.append(properties(deepness, "Property", schema.getProperties(), true));
+        sb.append(properties(deepness, "Property", schema.getProperties(), true, context));
         if (schema instanceof ComposedSchema) {
-            sb.append(schema(deepness, (ComposedSchema) schema));
+            sb.append(schema(deepness, (ComposedSchema) schema, context));
         } else if (schema instanceof ArraySchema) {
-            sb.append(items(deepness, resolve(((ArraySchema) schema).getItems())));
+            sb.append(items(deepness, resolve(((ArraySchema) schema).getItems()), context));
         }
         return sb.toString();
     }
 
-    protected String items(int deepness, Schema schema) {
+    protected String items(int deepness, Schema schema, DiffContext context) {
         StringBuilder sb = new StringBuilder("");
         sb.append(format("%sItems (%s)%s\n", indent(deepness), type(schema), Arrays.asList("object", "array").contains(type(schema)) ? " :\n" : ""));
         description(indent(deepness + 1), schema.getDescription());
-        sb.append(schema(deepness, schema));
+        sb.append(schema(deepness, schema, context));
         return sb.toString();
     }
 
-    protected String properties(final int deepness, String title, Map<String, Schema> properties, boolean showContent) {
+    protected String properties(final int deepness, String title, Map<String, Schema> properties, boolean showContent, DiffContext context) {
         StringBuilder sb = new StringBuilder("");
         if (properties != null) {
             properties.forEach((key, value) -> {
                 sb.append(property(deepness, title, key, resolve(value)));
                 if (showContent) {
-                    sb.append(schema(deepness + 1, resolve(value)));
+                    sb.append(schema(deepness + 1, resolve(value), context));
                 }
             });
         }