Merge master into swagger-snapshot

Dockerfile

@@ -0,0 +1,18 @@
+FROM maven:3.5-jdk-8-alpine as build
+WORKDIR /app
+COPY ./ /app
+RUN mvn install -q && \
+  mvn package -q && \
+  ls /app/target/ && \
+  MVN_VERSION=$(mvn -q \
+    -Dexec.executable="echo" \
+    -Dexec.args='${project.version}' \
+    --non-recursive \
+    org.codehaus.mojo:exec-maven-plugin:1.6.0:exec) && \
+  mv /app/target/openapi-diff-${MVN_VERSION}-jar-with-dependencies.jar /app/openapi-diff.jar
+
+FROM openjdk:8-jre-alpine
+WORKDIR /app
+COPY --from=0 /app/openapi-diff.jar /app
+ENTRYPOINT ["java", "-jar", "/app/openapi-diff.jar"]
+CMD ["--help"]

README.md

@@ -26,6 +26,33 @@ Available on [Maven Central](https://search.maven.org/#search%7Cgav%7C1%7Cg%3A%2
 </dependency>
 ```
 
+# Docker
+
+Available on [Docker Hub](https://hub.docker.com/r/quen2404/openapi-diff/) as `quen2404/openapi-diff`.
+
+## Build the image
+
+This is only required if you want to try new changes in the Dockerfile of this project.
+
+```bash
+docker build -t local-openapi-diff .
+```
+
+You can replace the local image name `local-openapi-diff` by any name of your choice.
+
+## Run an instance
+
+In this example the `$(pwd)/src/test/resources` directory is mounted in the `/specs` directory of the container
+in readonly mode (`ro`).
+
+```bash
+docker run -t \
+  -v $(pwd)/src/test/resources:/specs:ro \
+  quen2404/openapi-diff /specs/path_1.yaml /specs/path_2.yaml
+```
+
+The remote name `quen2404/openapi-diff` can be replaced with `local-openapi-diff` or the name you gave to your local image.
+
 # Usage
 OpenDiff can read swagger api spec from json file or http.
 
@@ -102,6 +129,11 @@ try {
 }
 ```
 
+### Extensions
+This project uses Java Service Provider Inteface (SPI) so additional extensions can be added. 
+
+To build your own extension, you simply need to create a `src/main/resources/META-INF/services/com.qdesrame.openapi.diff.compare.ExtensionDiff` file with the full classname of your implementation.  Your class must also implement the `com.qdesrame.openapi.diff.compare.ExtensionDiff` interface.  Then, including your library with the `openapi-diff` module will cause it to be triggered automatically.
+
 # Example
 ### CLI Output
 

pom.xml

@@ -9,7 +9,7 @@
 
     <groupId>com.qdesrame</groupId>
     <artifactId>openapi-diff</artifactId>
-    <version>1.2.1-SNAPSHOT</version>
+    <version>2.0.0-SNAPSHOT</version>
     <packaging>jar</packaging>
 
     <name>openapi-diff</name>
@@ -216,6 +216,15 @@
                         <descriptorRef>jar-with-dependencies</descriptorRef>
                     </descriptorRefs>
                 </configuration>
+                <executions>
+                    <execution>
+                        <id>make-assembly</id>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>single</goal>
+                        </goals>
+                    </execution>
+                </executions>
             </plugin>
         </plugins>
     </build>

src/main/java/com/qdesrame/openapi/diff/Main.java

@@ -131,10 +131,10 @@ public static void main(String... args) {
                 }
             }
             if (line.hasOption("state")) {
-                System.out.println(result.isDiff() ? result.isDiffBackwardCompatible() ? "compatible" : "incompatible" : "no_changes");
+                System.out.println(result.isChanged().getValue());
                 System.exit(0);
             } else {
-                System.exit(result.isDiff() ? 1 : 0);
+                System.exit(result.isUnchanged() ? 0 : 1);
             }
         } catch (ParseException e) {
             // oops, something went wrong

src/main/java/com/qdesrame/openapi/diff/compare/ApiResponseDiff.java

@@ -2,6 +2,7 @@
 
 import com.qdesrame.openapi.diff.model.ChangedApiResponse;
 import com.qdesrame.openapi.diff.model.ChangedResponse;
+import com.qdesrame.openapi.diff.model.DiffContext;
 import io.swagger.v3.oas.models.responses.ApiResponse;
 import io.swagger.v3.oas.models.responses.ApiResponses;
 
@@ -10,6 +11,8 @@
 import java.util.Map;
 import java.util.Optional;
 
+import static com.qdesrame.openapi.diff.utils.ChangedUtils.isChanged;
+
 /**
  * Created by adarsh.sharma on 04/01/18.
  */
@@ -20,19 +23,18 @@ public ApiResponseDiff(OpenApiDiff openApiDiff) {
         this.openApiDiff = openApiDiff;
     }
 
-    public Optional<ChangedApiResponse> diff(ApiResponses left, ApiResponses right) {
+    public Optional<ChangedApiResponse> diff(ApiResponses left, ApiResponses right, DiffContext context) {
         MapKeyDiff<String, ApiResponse> responseMapKeyDiff = MapKeyDiff.diff(left, right);
-        ChangedApiResponse changedApiResponse = new ChangedApiResponse(left, right);
+        ChangedApiResponse changedApiResponse = new ChangedApiResponse(left, right, context);
         changedApiResponse.setAddResponses(responseMapKeyDiff.getIncreased());
         changedApiResponse.setMissingResponses(responseMapKeyDiff.getMissing());
         List<String> sharedResponseCodes = responseMapKeyDiff.getSharedKey();
-
         Map<String, ChangedResponse> resps = new HashMap<>();
         for (String responseCode : sharedResponseCodes) {
-            openApiDiff.getResponseDiff().diff(left.get(responseCode), right.get(responseCode))
+            openApiDiff.getResponseDiff().diff(left.get(responseCode), right.get(responseCode), context)
                     .ifPresent(changedResponse -> resps.put(responseCode, changedResponse));
         }
         changedApiResponse.setChangedResponses(resps);
-        return changedApiResponse.isDiff() ? Optional.of(changedApiResponse) : Optional.empty();
+        return isChanged(changedApiResponse);
     }
 }

src/main/java/com/qdesrame/openapi/diff/compare/CacheKey.java

@@ -0,0 +1,43 @@
+package com.qdesrame.openapi.diff.compare;
+
+import com.qdesrame.openapi.diff.model.DiffContext;
+import lombok.Getter;
+import org.apache.commons.lang3.builder.EqualsBuilder;
+import org.apache.commons.lang3.builder.HashCodeBuilder;
+
+@Getter
+public final class CacheKey {
+    private final String left;
+    private final String right;
+    private final DiffContext context;
+
+    public CacheKey(final String left, final String right, final DiffContext context) {
+        this.left = left;
+        this.right = right;
+        this.context = context;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+
+        if (o == null || getClass() != o.getClass()) return false;
+
+        CacheKey cacheKey = (CacheKey) o;
+
+        return new EqualsBuilder()
+                .append(left, cacheKey.left)
+                .append(right, cacheKey.right)
+                .append(context, cacheKey.context)
+                .isEquals();
+    }
+
+    @Override
+    public int hashCode() {
+        return new HashCodeBuilder(17, 37)
+                .append(left)
+                .append(right)
+                .append(context)
+                .toHashCode();
+    }
+}

src/main/java/com/qdesrame/openapi/diff/compare/ContentDiff.java

@@ -2,11 +2,15 @@
 
 import com.qdesrame.openapi.diff.model.ChangedContent;
 import com.qdesrame.openapi.diff.model.ChangedMediaType;
+import com.qdesrame.openapi.diff.model.DiffContext;
 import io.swagger.v3.oas.models.media.Content;
 import io.swagger.v3.oas.models.media.MediaType;
 
 import java.util.*;
 
+import static com.qdesrame.openapi.diff.utils.ChangedUtils.isChanged;
+import static com.qdesrame.openapi.diff.utils.ChangedUtils.isUnchanged;
+
 public class ContentDiff implements Comparable<Content> {
 
     private OpenApiDiff openApiDiff;
@@ -20,8 +24,8 @@ public boolean compare(Content left, Content right) {
         return false;
     }
 
-    public Optional<ChangedContent> diff(Content left, Content right) {
-        ChangedContent changedContent = new ChangedContent(left, right);
+    public Optional<ChangedContent> diff(Content left, Content right, DiffContext context) {
+        ChangedContent changedContent = new ChangedContent(left, right, context);
 
         MapKeyDiff<String, MediaType> mediaTypeDiff = MapKeyDiff.diff(left, right);
         changedContent.setIncreased(mediaTypeDiff.getIncreased());
@@ -31,13 +35,13 @@ public Optional<ChangedContent> diff(Content left, Content right) {
         for (String mediaTypeKey : sharedMediaTypes) {
             MediaType oldMediaType = left.get(mediaTypeKey);
             MediaType newMediaType = right.get(mediaTypeKey);
-            ChangedMediaType changedMediaType = new ChangedMediaType(oldMediaType.getSchema(), newMediaType.getSchema());
-            openApiDiff.getSchemaDiff().diff(new HashSet<>(), oldMediaType.getSchema(), newMediaType.getSchema()).ifPresent(changedMediaType::setChangedSchema);
-            if (changedMediaType.isDiff()) {
+            ChangedMediaType changedMediaType = new ChangedMediaType(oldMediaType.getSchema(), newMediaType.getSchema(), context);
+            openApiDiff.getSchemaDiff().diff(new HashSet<>(), oldMediaType.getSchema(), newMediaType.getSchema(), context.copyWithRequired(true)).ifPresent(changedMediaType::setChangedSchema);
+            if (!isUnchanged(changedMediaType)) {
                 changedMediaTypes.put(mediaTypeKey, changedMediaType);
             }
         }
         changedContent.setChanged(changedMediaTypes);
-        return changedContent.isDiff() ? Optional.of(changedContent) : Optional.empty();
+        return isChanged(changedContent);
     }
 }

src/main/java/com/qdesrame/openapi/diff/compare/ExtensionDiff.java

@@ -0,0 +1,15 @@
+package com.qdesrame.openapi.diff.compare;
+
+import com.qdesrame.openapi.diff.model.Changed;
+import com.qdesrame.openapi.diff.model.DiffContext;
+
+import java.util.Optional;
+
+public interface ExtensionDiff {
+
+    ExtensionDiff setOpenApiDiff(OpenApiDiff openApiDiff);
+
+    String getName();
+
+    Optional<Changed> diff(Object left, Object right, DiffContext context);
+}

src/main/java/com/qdesrame/openapi/diff/compare/ExtensionsDiff.java

@@ -0,0 +1,43 @@
+package com.qdesrame.openapi.diff.compare;
+
+import com.qdesrame.openapi.diff.model.DiffContext;
+import com.qdesrame.openapi.diff.model.schema.ChangedExtensions;
+
+import java.util.*;
+
+import static com.qdesrame.openapi.diff.utils.ChangedUtils.isChanged;
+
+public class ExtensionsDiff {
+    private final OpenApiDiff openApiDiff;
+
+    private ServiceLoader<ExtensionDiff> extensionsLoader = ServiceLoader.load(ExtensionDiff.class);
+    private List<ExtensionDiff> extensionsDiff = new ArrayList<>();
+
+    public ExtensionsDiff(OpenApiDiff openApiDiff) {
+        this.openApiDiff = openApiDiff;
+        this.extensionsLoader.reload();
+        for (ExtensionDiff anExtensionsLoader : this.extensionsLoader) {
+            extensionsDiff.add(anExtensionsLoader);
+        }
+    }
+
+    public Optional<ChangedExtensions> diff(Map<String, Object> left, Map<String, Object> right, DiffContext context) {
+        if (null == left) left = new HashMap<>();
+        if (null == right) right = new HashMap<>();
+        ChangedExtensions changedExtensions = new ChangedExtensions(left, new HashMap<>(right), context);
+        changedExtensions.getIncreased().putAll(right);
+        for (String key : left.keySet()) {
+            if (changedExtensions.getIncreased().containsKey(key)) {
+                Optional<ExtensionDiff> extensionDiff = extensionsDiff.stream()
+                        .filter(diff -> ("x-" + diff.getName()).equals(key)).findFirst();
+                Object leftValue = left.get(key);
+                Object rightValue = changedExtensions.getIncreased().remove(key);
+                extensionDiff.ifPresent(diff -> diff.setOpenApiDiff(openApiDiff).diff(leftValue, rightValue, context)
+                        .ifPresent(changed -> changedExtensions.getChanged().put(key, changed)));
+            } else {
+                changedExtensions.getMissing().put(key, left.get(key));
+            }
+        }
+        return isChanged(changedExtensions);
+    }
+}

src/main/java/com/qdesrame/openapi/diff/compare/HeaderDiff.java

@@ -1,6 +1,7 @@
 package com.qdesrame.openapi.diff.compare;
 
 import com.qdesrame.openapi.diff.model.ChangedHeader;
+import com.qdesrame.openapi.diff.model.DiffContext;
 import com.qdesrame.openapi.diff.utils.RefPointer;
 import com.qdesrame.openapi.diff.utils.RefType;
 import io.swagger.v3.oas.models.Components;
@@ -10,6 +11,8 @@
 import java.util.Objects;
 import java.util.Optional;
 
+import static com.qdesrame.openapi.diff.utils.ChangedUtils.isChanged;
+
 /**
  * Created by adarsh.sharma on 28/12/17.
  */
@@ -25,26 +28,26 @@ public HeaderDiff(OpenApiDiff openApiDiff) {
         this.rightComponents = openApiDiff.getNewSpecOpenApi() != null ? openApiDiff.getNewSpecOpenApi().getComponents() : null;
     }
 
-    public Optional<ChangedHeader> diff(Header left, Header right) {
-        return cachedDiff(new HashSet<>(), left, right, left.get$ref(), right.get$ref());
+    public Optional<ChangedHeader> diff(Header left, Header right, DiffContext context) {
+        return cachedDiff(new HashSet<>(), left, right, left.get$ref(), right.get$ref(), context);
     }
 
     @Override
-    protected Optional<ChangedHeader> computeDiff(HashSet<String> refSet, Header left, Header right) {
+    protected Optional<ChangedHeader> computeDiff(HashSet<String> refSet, Header left, Header right, DiffContext context) {
         left = refPointer.resolveRef(leftComponents, left, left.get$ref());
         right = refPointer.resolveRef(rightComponents, right, right.get$ref());
 
-        ChangedHeader changedHeader = new ChangedHeader(left, right);
+        ChangedHeader changedHeader = new ChangedHeader(left, right, context);
 
         changedHeader.setChangeDescription(!Objects.equals(left.getDescription(), right.getDescription()));
         changedHeader.setChangeRequired(getBooleanDiff(left.getRequired(), right.getRequired()));
         changedHeader.setChangeDeprecated(!Boolean.TRUE.equals(left.getDeprecated()) && Boolean.TRUE.equals(right.getDeprecated()));
         changedHeader.setChangeStyle(!Objects.equals(left.getStyle(), right.getStyle()));
         changedHeader.setChangeExplode(getBooleanDiff(left.getExplode(), right.getExplode()));
-        openApiDiff.getSchemaDiff().diff(new HashSet<>(), left.getSchema(), right.getSchema()).ifPresent(changedHeader::setChangedSchema);
-        openApiDiff.getContentDiff().diff(left.getContent(), right.getContent()).ifPresent(changedHeader::setChangedContent);
+        openApiDiff.getSchemaDiff().diff(new HashSet<>(), left.getSchema(), right.getSchema(), context.copyWithRequired(true)).ifPresent(changedHeader::setChangedSchema);
+        openApiDiff.getContentDiff().diff(left.getContent(), right.getContent(), context).ifPresent(changedHeader::setChangedContent);
 
-        return changedHeader.isDiff() ? Optional.of(changedHeader) : Optional.empty();
+        return isChanged(changedHeader);
     }
 
     private boolean getBooleanDiff(Boolean left, Boolean right) {

src/main/java/com/qdesrame/openapi/diff/compare/HeadersDiff.java

@@ -2,13 +2,16 @@
 
 import com.qdesrame.openapi.diff.model.ChangedHeader;
 import com.qdesrame.openapi.diff.model.ChangedHeaders;
+import com.qdesrame.openapi.diff.model.DiffContext;
 import io.swagger.v3.oas.models.headers.Header;
 
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 
+import static com.qdesrame.openapi.diff.utils.ChangedUtils.isChanged;
+
 /**
  * Created by adarsh.sharma on 28/12/17.
  */
@@ -19,8 +22,8 @@ public HeadersDiff(OpenApiDiff openApiDiff) {
         this.openApiDiff = openApiDiff;
     }
 
-    public Optional<ChangedHeaders> diff(Map<String, Header> left, Map<String, Header> right) {
-        ChangedHeaders changedHeaders = new ChangedHeaders(left, right);
+    public Optional<ChangedHeaders> diff(Map<String, Header> left, Map<String, Header> right, DiffContext context) {
+        ChangedHeaders changedHeaders = new ChangedHeaders(left, right, context);
         MapKeyDiff<String, Header> headerMapDiff = MapKeyDiff.diff(left, right);
         changedHeaders.setIncreased(headerMapDiff.getIncreased());
         changedHeaders.setMissing(headerMapDiff.getMissing());
@@ -30,11 +33,11 @@ public Optional<ChangedHeaders> diff(Map<String, Header> left, Map<String, Heade
         for (String headerKey : sharedHeaderKeys) {
             Header oldHeader = left.get(headerKey);
             Header newHeader = right.get(headerKey);
-            openApiDiff.getHeaderDiff().diff(oldHeader, newHeader)
+            openApiDiff.getHeaderDiff().diff(oldHeader, newHeader, context)
                     .ifPresent(changedHeader -> changed.put(headerKey, changedHeader));
         }
         changedHeaders.setChanged(changed);
 
-        return changedHeaders.isDiff() ? Optional.of(changedHeaders) : Optional.empty();
+        return isChanged(changedHeaders);
     }
 }