refactor command line related code

Author: olegthelilfix

src/main/java/io/squark/swaggercombine/CommandLineArguments.kt

@@ -1,4 +1,40 @@
+/**
+ * Copyright (C) 2022 Oleg Aleksandrov
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
 package io.squark.swaggercombine
 
-enum class CommandLineArguments {
+/**
+ * Represents a command line property.
+ *
+ * @author Oleg Aleksandrov
+ * @since 0.2.0
+ */
+enum class CommandLineArguments(
+    /**
+     * Contains the current value for this command line property.
+     */
+    val value: String
+) {
+    /**
+     * The command line key to the path to output file.
+     */
+    OUTPUT_FILE("--outputFile"),
+
+    /**
+     * The command line key to the strip base path property.
+     */
+    STRIP_BASE_PATH("--stripBasePath"),
+    /**
+     * The command line key to the path to input file.
+     */
+    INPUT_FILE("--inputFile"),
 }

src/main/java/io/squark/swaggercombine/CommandLineProperties.kt

@@ -0,0 +1,55 @@
+/**
+ * Copyright (C) 2022 Oleg Aleksandrov
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package io.squark.swaggercombine
+
+/**
+ * Utility class for parse command line arguments.
+ *
+ * @author Oleg Aleksandrov
+ * @since 0.2.0
+ */
+class CommandLinePropertiesParser(args: Array<String>) {
+    private val properties: Map<CommandLineArguments, List<String>> = parseCommandLineProperties(args)
+
+    /**
+     * Returns list of values associated to given command line argument.
+     * @since 0.2.0
+     */
+    fun get(arg: CommandLineArguments): List<String> {
+        return properties[arg] ?: emptyList()
+    }
+
+    private fun parseCommandLineProperties(args: Array<String>): Map<CommandLineArguments, List<String>> {
+        val properties = mutableMapOf<CommandLineArguments, MutableList<String>>()
+
+        for (i in args.indices) {
+            val arg = args[i]
+            if (arg.startsWith("--")) {
+                val key: CommandLineArguments = parseCommandLineKey(arg)
+                    ?: throw RuntimeException("Unknown command line argument: $arg")
+
+                val value = args[i + 1]
+
+                val arguments = properties.getOrDefault(key, mutableListOf())
+                arguments.add(value)
+                properties[key] = arguments
+            }
+        }
+
+        return properties
+    }
+
+    private fun parseCommandLineKey(key: String): CommandLineArguments? {
+        return CommandLineArguments.values().firstOrNull { key == it.value }
+    }
+}

src/main/java/io/squark/swaggercombine/CommandLinePropertiesParser.kt

@@ -1,16 +1,15 @@
 /**
  * Copyright (C) 2007 Erik Håkansson
  * Copyright (C) 2022 Oleg Aleksandrov
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
- * in compliance with the License. You may obtain a copy of the License at
- *
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * <p>
  * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under the License
- * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
- * or implied. See the License for the specific language governing permissions and limitations under
- * the License.
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
  */
 package io.squark.swaggercombine;
 
@@ -19,7 +18,6 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
-import java.util.Properties;
 
 import org.apache.commons.io.IOUtils;
 
@@ -50,12 +48,12 @@ public class SwaggerCombine {
 
     private Swagger firstSwagger;
     private List<Swagger> swaggers = new ArrayList<>();
-    private Properties properties;
+    private final CommandLinePropertiesParser properties;
 
-    public SwaggerCombine(List<String> files, Properties properties) throws Exception {
+    public SwaggerCombine(CommandLinePropertiesParser properties) throws Exception {
         this.properties = properties;
         boolean first = true;
-        for (String fileName : files) {
+        for (String fileName : properties.get(CommandLineArguments.INPUT_FILE)) {
             File file = new File(fileName);
             if (!file.exists()) {
                 throw new Exception("File not found: " + file.getAbsolutePath());
@@ -72,9 +70,14 @@ public SwaggerCombine(List<String> files, Properties properties) throws Exceptio
     }
 
     public Swagger combine() {
+        String useStripBasePath =
+                properties.get(CommandLineArguments.STRIP_BASE_PATH)
+                        .stream()
+                        .findFirst()
+                        .orElse("false");
+
+        boolean stripBasePath = Boolean.parseBoolean(useStripBasePath);
 
-        boolean stripBasePath = (properties != null &&
-                Boolean.parseBoolean(properties.getProperty("--stripBasePath", "false")));
         for (Swagger swagger : swaggers) {
             if (swagger.getTags() != null) {
                 for (Tag tag : swagger.getTags()) {
@@ -148,22 +151,15 @@ public Swagger combine() {
     }
 
     public static void main(String[] args) throws Exception {
-        if (args.length < 2) {
+        CommandLinePropertiesParser properties = new CommandLinePropertiesParser(args);
+
+        if (properties.get(CommandLineArguments.INPUT_FILE).size() < 2) {
             System.out.println("usage: swagger-combine base.json swagger2.json swagger3.json");
             System.out.println("Please use at least two input files");
             System.exit(1);
         }
-        List<String> arguments = new ArrayList<>();
-        Properties properties = new Properties();
-        for (String arg : args) {
-            if (arg.startsWith("--")) {
-                String[] split = arg.split("=");
-                properties.setProperty(split[0], split[1]);
-            } else {
-                arguments.add(arg);
-            }
-        }
-        SwaggerCombine swaggerCombine = new SwaggerCombine(arguments, properties);
+
+        SwaggerCombine swaggerCombine = new SwaggerCombine(properties);
         Swagger combined = swaggerCombine.combine();
 
         ObjectMapper mapper = Json.mapper();
@@ -175,10 +171,12 @@ public static void main(String[] args) throws Exception {
         mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
         mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 
-        String outputFile = properties.getProperty("--outputFile");
-        if (outputFile == null) {
-            outputFile = "result.json";
-        }
+        String outputFile =
+                properties.get(CommandLineArguments.OUTPUT_FILE)
+                        .stream()
+                        .findFirst()
+                        .orElse("result.json");
+
         File output = new File(outputFile);
         mapper.writer(new DefaultPrettyPrinter()).writeValue(output, combined);
 

src/main/java/io/squark/swaggercombine/Swagger.kt

@@ -0,0 +1,91 @@
+/**
+ * Copyright (C) 2022 Oleg Aleksandrov
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package io.squark.swaggercombine
+
+import org.junit.Assert
+import org.junit.Test
+
+/**
+ * Tests for [CommandLinePropertiesParser]
+ *
+ * @author Oleg Aleksandrov
+ * @since 0.2.0
+ */
+class CommandLinePropertiesParserTest {
+
+    @Test
+    fun `Inputs set up correctly`() {
+        val inputFileName1 = "test1.json"
+        val inputFileName2 = "test2.json"
+
+        val parser = CommandLinePropertiesParser(
+            arrayOf(
+                CommandLineArguments.INPUT_FILE.value,
+                inputFileName1,
+                CommandLineArguments.INPUT_FILE.value,
+                inputFileName2,
+            )
+        )
+
+        val inputs = parser.get(CommandLineArguments.INPUT_FILE)
+        Assert.assertTrue("Inputs should contains $inputFileName1", inputs.contains(inputFileName1))
+        Assert.assertTrue("Inputs should contains $inputFileName2", inputs.contains(inputFileName2))
+    }
+
+    @Test
+    fun `Output set up correctly`() {
+        val outputFileName = "output.json"
+        val parser = CommandLinePropertiesParser(
+            arrayOf(
+                CommandLineArguments.OUTPUT_FILE.value,
+                outputFileName,
+            )
+        )
+
+        val outputs = parser.get(CommandLineArguments.OUTPUT_FILE)
+        Assert.assertTrue("Outputs should contains $outputFileName", outputs.contains(outputFileName))
+    }
+
+    @Test
+    fun `Strip base path set up correctly`() {
+        val stripBasePath = true
+        val parser = CommandLinePropertiesParser(
+            arrayOf(
+                CommandLineArguments.STRIP_BASE_PATH.value,
+                stripBasePath.toString()
+            )
+        )
+
+        val stripBasePaths = parser.get(CommandLineArguments.STRIP_BASE_PATH)
+        Assert.assertTrue("Strip base paths should contains $stripBasePath", stripBasePaths.contains(stripBasePath.toString()))
+    }
+
+    @Test
+    fun `Default properties value`() {
+        val parser = CommandLinePropertiesParser(arrayOf())
+
+        Assert.assertTrue("Inputs should be empty", parser.get(CommandLineArguments.INPUT_FILE).isEmpty())
+        Assert.assertTrue("Output file name should be empty", parser.get(CommandLineArguments.OUTPUT_FILE).isEmpty())
+        Assert.assertTrue("Strip base path should be empty", parser.get(CommandLineArguments.STRIP_BASE_PATH).isEmpty())
+    }
+
+    @Test(expected = RuntimeException::class)
+    fun `Wrong argument`() {
+        CommandLinePropertiesParser(
+            arrayOf(
+                "--wrong argument",
+                "wrong argument",
+            )
+        )
+    }
+}