Merge pull request #1 from silentsoft/dev

v1.1.0 dev branch into master branch

CHANGELOG.md

@@ -1,2 +1,5 @@
+## 1.1.0 (10 Jul 2020)
+  - Fix identity issue and missing key problem
+
 ## 1.0.0 (9 Jul 2020)
   - The first proper release

README.md

@@ -1,7 +1,8 @@
 # Arguments Parser
 
-![release](https://img.shields.io/badge/release-v1.0.0-blue.svg)
+![release](https://img.shields.io/badge/release-v1.1.0-blue.svg)
 [![Build Status](https://travis-ci.com/silentsoft/arguments-parser.svg?branch=master)](https://travis-ci.com/silentsoft/arguments-parser)
+[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=silentsoft_arguments-parser&metric=alert_status)](https://sonarcloud.io/dashboard?id=silentsoft_arguments-parser)
 [![Coverage](https://sonarcloud.io/api/project_badges/measure?project=silentsoft_arguments-parser&metric=coverage)](https://sonarcloud.io/dashboard?id=silentsoft_arguments-parser)
 [![HitCount](http://hits.dwyl.com/silentsoft/arguments-parser.svg)](http://hits.dwyl.com/silentsoft/arguments-parser)
 
@@ -27,7 +28,7 @@
     <dependency>
         <groupId>org.silentsoft</groupId>
         <artifactId>arguments-parser</artifactId>
-        <version>1.0.0</version>
+        <version>1.1.0</version>
     </dependency>
 </dependencies>
 ```

pom.xml

@@ -6,7 +6,7 @@
 
 	<groupId>org.silentsoft</groupId>
 	<artifactId>arguments-parser</artifactId>
-	<version>1.0.0</version>
+	<version>1.1.0</version>
 
 	<name>Arguments Parser</name>
 	<description>Arguments Parser is a simple java library to parse command line arguments.</description>

src/main/java/org/silentsoft/arguments/parser/Argument.java

@@ -35,11 +35,20 @@ protected static Argument of(String key, String... values) {
 		return argument;
 	}
 
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+		int result = 1;
+		result = prime * result + key.hashCode();
+		result = prime * result + values.hashCode();
+		return result;
+	}
+
 	@Override
 	public boolean equals(Object obj) {
 		return obj == null ? false : toString().equals(obj.toString());
 	}
-
+	
 	@Override
 	public int compareTo(Argument o) {
 		return toString().compareTo(o.toString());

src/main/java/org/silentsoft/arguments/parser/Arguments.java

@@ -37,6 +37,10 @@ public int size() {
 		return set.size();
 	}
 
+	public boolean isEmpty() {
+		return set.isEmpty();
+	}
+
 	public Argument get(String key) {
 		Optional<Argument> optional = stream(key).findAny();
 		return optional.isPresent() ? optional.get() : null;
@@ -79,13 +83,13 @@ public Arguments with(ParsingOptions... parsingOptions) throws InvalidArgumentsE
 			source = set;
 		}
 		Function<String, String> transform = (key) -> {
-			return getOptions().contains(ParsingOptions.REMOVE_DASH_PREFIX) ? removeDashPrefix(key) : key;
+			return getOptions().contains(ParsingOptions.REMOVE_DASH_PREFIX) ? key.replaceFirst("(-)+", "") : key;
 		};
 		source.forEach(argument -> {
 			String key;
 			if (argument.getKey().startsWith("--") && getOptions().contains(ParsingOptions.CASE_INSENSITIVE_DOUBLE_DASH)) {
 				key = argument.getKey().toLowerCase();
-			} else if (argument.getKey().startsWith("-") && argument.getKey().startsWith("--") == false && getOptions().contains(ParsingOptions.CASE_INSENSITIVE_SINGLE_DASH)) {
+			} else if (argument.getKey().startsWith("--") == false && getOptions().contains(ParsingOptions.CASE_INSENSITIVE_SINGLE_DASH)) {
 				key = argument.getKey().toLowerCase();
 			} else if (getOptions().contains(ParsingOptions.CASE_INSENSITIVE)) {
 				key = argument.getKey().toLowerCase();
@@ -197,21 +201,6 @@ private Stream<Argument> stream(String key) {
 		return set.stream().filter(predicate);
 	}
 
-	private String removeDashPrefix(String value) {
-		int index = 0;
-
-		char[] charArray = value.toCharArray();
-		for (int length=charArray.length; index<length; index++) {
-			if (charArray[index] == '-') {
-				continue;
-			}
-
-			break;
-		}
-
-		return value.substring(index);
-	}
-
 	@Override
 	public Iterator<Argument> iterator() {
 		return set.iterator();

src/main/java/org/silentsoft/arguments/parser/ArgumentsParser.java

@@ -67,6 +67,10 @@ public static Arguments parse(String[] args, ArgumentsValidator validator) throw
 		if (args != null) {
 			for (String arg : args) {
 				if (arg.startsWith("-")) {
+					if (arg.matches("(-)+")) {
+						throw new InvalidArgumentsException("The argument key is missing.");
+					}
+
 					int indexOfEqual = arg.indexOf("=");
 					if (indexOfEqual == -1) {
 						arguments.add(Argument.of(arg));
@@ -75,11 +79,11 @@ public static Arguments parse(String[] args, ArgumentsValidator validator) throw
 						arguments.add(Argument.of(pair[0], pair[1]));
 					}
 				} else {
-					if (arguments.size() > 0) {
-						arguments.last().getValues().add(arg);
-					} else {
+					if (arguments.isEmpty()) {
 						throw new InvalidArgumentsException("The first argument must be starts with '-' or '--'.");
 					}
+
+					arguments.last().getValues().add(arg);
 				}
 			}
 		}

src/test/java/org/silentsoft/arguments/parser/ArgumentsParserTest.java

@@ -1,5 +1,6 @@
 package org.silentsoft.arguments.parser;
 
+import java.util.HashMap;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Predicate;
 
@@ -21,11 +22,6 @@ public void parseTest() throws InvalidArgumentsException {
 			Assert.assertNotNull(arguments);
 			Assert.assertEquals(0, arguments.size());
 		}
-		{
-			Assert.assertTrue(Argument.of("A").equals(Argument.of("A")));
-			Assert.assertFalse(Argument.of("a").equals(Argument.of("A")));
-			Assert.assertFalse(Argument.of("a").equals(null));
-		}
 		{
 			Arguments arguments = ArgumentsParser.parse(new String[] {"-a", "--a", "---a"});
 			Assert.assertEquals(3, arguments.size());
@@ -68,6 +64,10 @@ public void parseTest() throws InvalidArgumentsException {
 			Assert.assertEquals("B", arguments.get("--a").getValue());
 			Assert.assertEquals("B", arguments.get("--A").getValue());
 		}
+		{
+			Arguments arguments = ArgumentsParser.parse(new String[] {"--hello-world"});
+			Assert.assertNotNull(arguments.get("--hello-world"));
+		}
 		{
 			Arguments arguments = ArgumentsParser.parse(new String[] {"-key=value"});
 			Assert.assertEquals(1, arguments.size());
@@ -286,11 +286,66 @@ public void iterationTest() throws InvalidArgumentsException {
 		}
 	}
 
+	@Test
+	public void identityTest() throws InvalidArgumentsException {
+		{
+			HashMap<Argument, Integer> map = new HashMap<Argument, Integer>();
+			map.put(Argument.of("a"), 1);
+			map.put(Argument.of("a"), 2);
+			Assert.assertEquals(1, map.size());
+			Assert.assertTrue(map.get(Argument.of("a")) == 2);
+		}
+		{
+			HashMap<Argument, Integer> map = new HashMap<Argument, Integer>();
+			map.put(Argument.of("a", "b"), 1);
+			map.put(Argument.of("a", "b"), 2);
+			Assert.assertEquals(1, map.size());
+			Assert.assertTrue(map.get(Argument.of("a", "b")) == 2);
+		}
+		{
+			HashMap<Argument, Integer> map = new HashMap<Argument, Integer>();
+			map.put(Argument.of("a", "b", "c"), 1);
+			map.put(Argument.of("a", "b", "c"), 2);
+			Assert.assertEquals(1, map.size());
+			Assert.assertTrue(map.get(Argument.of("a", "b", "c")) == 2);
+		}
+		{
+			HashMap<Argument, Integer> map = new HashMap<Argument, Integer>();
+			map.put(Argument.of("a", new String[] {"b"}), 1);
+			map.put(Argument.of("a", new String[] {"b"}), 2);
+			Assert.assertEquals(1, map.size());
+			Assert.assertTrue(map.get(Argument.of("a", new String[] {"b"})) == 2);
+		}
+		{
+			HashMap<Argument, Integer> map = new HashMap<Argument, Integer>();
+			map.put(Argument.of("a", new String[] {"b", "c"}), 1);
+			map.put(Argument.of("a", new String[] {"b", "c"}), 2);
+			Assert.assertEquals(1, map.size());
+			Assert.assertTrue(map.get(Argument.of("a", new String[] {"b", "c"})) == 2);
+		}
+	}
+
+	@Test
+	public void equalityTest() throws InvalidArgumentsException {
+		Assert.assertTrue(Argument.of("a").equals(Argument.of("a")));
+		Assert.assertFalse(Argument.of("a").equals(Argument.of("A")));
+		Assert.assertFalse(Argument.of("a").equals(null));
+		Assert.assertTrue(Argument.of("a", "b").equals(Argument.of("a", "b")));
+		Assert.assertTrue(Argument.of("a", "b", "c").equals(Argument.of("a", "b", "c")));
+		Assert.assertTrue(Argument.of("a", new String[] {"b"}).equals(Argument.of("a", new String[] {"b"})));
+		Assert.assertTrue(Argument.of("a", new String[] {"b", "c"}).equals(Argument.of("a", new String[] {"b", "c"})));
+	}
+
 	@Test(expected = InvalidArgumentsException.class)
 	public void validatorFalseTest() throws InvalidArgumentsException {
 		ArgumentsParser.parse(new String[] {}, arguments -> false);
 	}
 
+	@Test(expected = InvalidArgumentsException.class)
+	public void missingKeyTest() throws InvalidArgumentsException {
+		ArgumentsParser.parse(new String[] {"--"});
+	}
+
 	@Test(expected = InvalidArgumentsException.class)
 	public void notStartsWithDashTest() throws InvalidArgumentsException {
 		ArgumentsParser.parse(new String[] {"a"});