Merge pull request #75 from osmlab/dev

Michael Cuthbert · web-flow · commit b4fb0f96901b · 2022-01-18T08:41:49.000-08:00
Merging to main
diff --git a/.github/workflows/pull-request.yml b/.github/workflows/pull-request.yml
@@ -0,0 +1,38 @@
+name: Pull Request Build
+on: [pull_request]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        # Jdk 17 requires gradle 7.3+ https://docs.gradle.org/current/userguide/compatibility.html
+        java: [11]
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+      - name: Set up JDK ${{ matrix.java }}
+        uses: actions/setup-java@v2
+        with:
+          distribution: 'zulu'
+          java-version: ${{ matrix.java }}
+      - uses: actions/cache@v2.1.7
+        id: gradle-cache
+        with:
+          path: |
+            ~/.gradle/caches
+          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle') }}
+      - uses: actions/cache@v2.1.7
+        id: gradle-wrapper-cache
+        with:
+          path: |
+            ~/.gradle/wrapper
+          key: ${{ runner.os }}-gradlewrapper-${{ hashFiles('gradle/wrapper/*') }}
+      - name: Build
+        run: ./gradlew build
+  validation:
+    name: "Gradle Validation"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: gradle/wrapper-validation-action@v1.0.4
diff --git a/src/integrationTest/java/org/maproulette/client/batch/BatchUploaderIntegrationTest.java b/src/integrationTest/java/org/maproulette/client/batch/BatchUploaderIntegrationTest.java
@@ -117,7 +117,8 @@ private void addDefaultTasks(final BatchUploader uploader, final long parentIden
             for (int taskIndex = 0; taskIndex < NUMBER_TASKS; taskIndex++)
             {
                 uploader.addTask(newChallenge, this.getDefaultTask(-1, "Task" + taskIndex));
-                LOG.debug("Added task name=Task{} parentId={} challengeName={}", taskIndex, parentIdentifier, newChallenge.getName());
+                LOG.debug("Added task name=Task{} parentId={} challengeName={}", taskIndex,
+                        parentIdentifier, newChallenge.getName());
             }
         }
     }
diff --git a/src/main/java/org/maproulette/client/model/RuleList.java b/src/main/java/org/maproulette/client/model/RuleList.java
@@ -1,5 +1,13 @@
 package org.maproulette.client.model;
 
+import java.io.IOException;
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.maproulette.client.exception.MapRouletteRuntimeException;
+import org.maproulette.client.utilities.ObjectMapperSingleton;
+
 import com.fasterxml.jackson.annotation.JsonValue;
 import com.fasterxml.jackson.core.JsonGenerator;
 import com.fasterxml.jackson.core.JsonParser;
@@ -11,17 +19,11 @@
 import com.fasterxml.jackson.databind.annotation.JsonSerialize;
 import com.fasterxml.jackson.databind.deser.std.StdDeserializer;
 import com.fasterxml.jackson.databind.ser.std.StdSerializer;
+
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
 import lombok.NoArgsConstructor;
-import org.maproulette.client.exception.MapRouletteRuntimeException;
-import org.maproulette.client.utilities.ObjectMapperSingleton;
-
-import java.io.IOException;
-import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.List;
 
 /**
  * @author mcuthbert
@@ -53,44 +55,48 @@ public String toJson()
         try
         {
             return ObjectMapperSingleton.getMapper().writeValueAsString(this);
-        } catch (final JsonProcessingException e)
+        }
+        catch (final JsonProcessingException e)
         {
             throw new MapRouletteRuntimeException(e);
         }
     }
 
+    /**
+     * Serialize a {@code RuleList}
+     */
     public static class RuleListSerializer extends StdSerializer<RuleList>
     {
-
         public RuleListSerializer()
         {
             this(null);
         }
 
-        public RuleListSerializer(Class<RuleList> t)
+        public RuleListSerializer(final Class<RuleList> clazzRuleList)
         {
-            super(t);
+            super(clazzRuleList);
         }
 
-        private static void serializeRuleListHelper(List<RuleList> ruleList, JsonGenerator gen) throws IOException
+        private static void serializeRuleListHelper(final List<RuleList> ruleListList,
+                final JsonGenerator gen) throws IOException
         {
-            for (RuleList r : ruleList)
+            for (final RuleList ruleList : ruleListList)
             {
                 gen.writeStartObject();
-                gen.writeStringField("condition", r.getCondition());
+                gen.writeStringField("condition", ruleList.getCondition());
                 gen.writeArrayFieldStart("rules");
-                if (r.getRuleList() != null)
+                if (ruleList.getRuleList() != null)
                 {
-                    for (RuleList it : r.getRuleList())
+                    for (final RuleList nestedRuleList : ruleList.getRuleList())
                     {
-                        serializeRuleListHelper(it.getRuleList(), gen);
+                        serializeRuleListHelper(nestedRuleList.getRuleList(), gen);
                     }
                 }
-                if (r.getRules() != null)
+                if (ruleList.getRules() != null)
                 {
-                    for (PriorityRule p : r.getRules())
+                    for (final PriorityRule priorityRule : ruleList.getRules())
                     {
-                        gen.writeObject(p);
+                        gen.writeObject(priorityRule);
                     }
                 }
                 gen.writeEndArray();
@@ -99,7 +105,8 @@ private static void serializeRuleListHelper(List<RuleList> ruleList, JsonGenerat
         }
 
         @Override
-        public void serialize(RuleList value, JsonGenerator gen, SerializerProvider serializers) throws IOException
+        public void serialize(final RuleList value, final JsonGenerator gen,
+                final SerializerProvider serializers) throws IOException
         {
             gen.writeStartObject();
             gen.writeStringField("condition", value.getCondition());
@@ -111,55 +118,56 @@ public void serialize(RuleList value, JsonGenerator gen, SerializerProvider seri
 
             if (value.getRules() != null)
             {
-                for (PriorityRule p : value.getRules())
+                for (final PriorityRule priorityRule : value.getRules())
                 {
-                    gen.writeObject(p);
+                    gen.writeObject(priorityRule);
                 }
             }
             gen.writeEndArray();
             gen.writeEndObject();
         }
     }
 
+    /**
+     * Deserialize a {@code RuleList}
+     */
     public static class RuleListDeserializer extends StdDeserializer<RuleList>
     {
-
         public RuleListDeserializer()
         {
             this(null);
         }
 
-        public RuleListDeserializer(final Class<?> vc)
+        public RuleListDeserializer(final Class<?> valueClass)
         {
-            super(vc);
+            super(valueClass);
         }
 
-        private static RuleList buildRuleListHelper(JsonNode node, DeserializationContext ctxt)
+        private static RuleList buildRuleListHelper(final JsonNode node,
+                final DeserializationContext ctxt)
         {
             if (node.get("condition") == null)
             {
                 return null;
             }
-            final RuleList ret = RuleList.builder()
-                    .condition(node.get("condition").asText())
-                    .ruleList(new ArrayList<>())
-                    .rules(new ArrayList<>())
-                    .build();
+            final RuleList ret = RuleList.builder().condition(node.get("condition").asText())
+                    .ruleList(new ArrayList<>()).rules(new ArrayList<>()).build();
 
-            for (JsonNode it : node.withArray("rules"))
+            for (final JsonNode jsonNode : node.withArray("rules"))
             {
-                if (it.get("condition") != null)
+                if (jsonNode.get("condition") != null)
                 {
-                    // If the child is a PriorityRule, do a recursive call to build the rule and add it to the list.
-                    RuleList child = buildRuleListHelper(it, ctxt);
+                    // If the child is a PriorityRule, do a recursive call to build the rule and add
+                    // it to the list.
+                    final RuleList child = buildRuleListHelper(jsonNode, ctxt);
                     ret.getRuleList().add(child);
-                } else
+                }
+                else
                 {
-                    PriorityRule priorityRule = PriorityRule.builder()
-                            .type(it.get("type").asText())
-                            .operator(it.get("operator").asText())
-                            .value(it.get("value").asText())
-                            .build();
+                    final PriorityRule priorityRule = PriorityRule.builder()
+                            .type(jsonNode.get("type").asText())
+                            .operator(jsonNode.get("operator").asText())
+                            .value(jsonNode.get("value").asText()).build();
                     ret.getRules().add(priorityRule);
                 }
             }
@@ -168,9 +176,10 @@ private static RuleList buildRuleListHelper(JsonNode node, DeserializationContex
         }
 
         @Override
-        public RuleList deserialize(JsonParser p, DeserializationContext ctxt) throws IOException
+        public RuleList deserialize(final JsonParser jsonParser, final DeserializationContext ctxt)
+                throws IOException
         {
-            JsonNode node = p.getCodec().readTree(p);
+            final JsonNode node = jsonParser.getCodec().readTree(jsonParser);
             return buildRuleListHelper(node, ctxt);
         }
     }
diff --git a/src/main/java/org/maproulette/client/utilities/ObjectMapperSingleton.java b/src/main/java/org/maproulette/client/utilities/ObjectMapperSingleton.java
@@ -1,10 +1,16 @@
 package org.maproulette.client.utilities;
 
+import org.maproulette.client.model.RuleList;
+
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.module.SimpleModule;
-import org.maproulette.client.model.RuleList;
 
-public class ObjectMapperSingleton
+/**
+ * ObjectMapperSingleton registers modules and provides a cached mapper.
+ *
+ * @author ljdelight
+ */
+public final class ObjectMapperSingleton
 {
     private static volatile ObjectMapper mapper;
 
@@ -17,7 +23,7 @@ public static ObjectMapper getMapper()
                 if (mapper == null)
                 {
                     mapper = new ObjectMapper();
-                    SimpleModule module = new SimpleModule();
+                    final SimpleModule module = new SimpleModule();
                     module.addSerializer(RuleList.class, new RuleList.RuleListSerializer());
                     module.addDeserializer(RuleList.class, new RuleList.RuleListDeserializer());
                     mapper.registerModule(module);
@@ -27,4 +33,8 @@ public static ObjectMapper getMapper()
 
         return mapper;
     }
+
+    private ObjectMapperSingleton()
+    {
+    }
 }
diff --git a/src/main/java/org/maproulette/client/utilities/Utilities.java b/src/main/java/org/maproulette/client/utilities/Utilities.java
@@ -1,9 +1,9 @@
 package org.maproulette.client.utilities;
 
-import org.maproulette.client.exception.MapRouletteException;
-
 import java.io.IOException;
 
+import org.maproulette.client.exception.MapRouletteException;
+
 /**
  * A generic helper class
  *
diff --git a/src/test/java/org/maproulette/client/serializer/ChallengeSerializationTest.java b/src/test/java/org/maproulette/client/serializer/ChallengeSerializationTest.java
@@ -12,9 +12,9 @@
 import org.maproulette.client.model.ChallengePriority;
 import org.maproulette.client.model.PriorityRule;
 import org.maproulette.client.model.RuleList;
+import org.maproulette.client.utilities.ObjectMapperSingleton;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
-import org.maproulette.client.utilities.ObjectMapperSingleton;
 
 /**
  * Tests whether a challenge can be read correctly from resources.
@@ -149,13 +149,11 @@ public void serializationTest() throws Exception
         final var highPriority = RuleList.builder().condition("AND")
                 .rules(Collections.singletonList(PriorityRule.builder().operator("equal")
                         .type("string").value("priority_pd.3").build()))
-                .ruleList(new ArrayList<>())
-                .build();
+                .ruleList(new ArrayList<>()).build();
         final var mediumPriority = RuleList.builder().condition("OR")
                 .rules(Collections.singletonList(PriorityRule.builder().operator("equal")
                         .type("string").value("priority_pd.2").build()))
-                .ruleList(new ArrayList<>())
-                .build();
+                .ruleList(new ArrayList<>()).build();
 
         Assertions.assertEquals(DESCRIPTION, deserializedChallenge.getDescription());
         Assertions.assertEquals(BLURB, deserializedChallenge.getBlurb());
diff --git a/src/test/java/org/maproulette/client/serializer/RuleListSerializationDeserializationTest.java b/src/test/java/org/maproulette/client/serializer/RuleListSerializationDeserializationTest.java

Original file line number	Diff line number	Diff line change
`@@ -117,7 +117,8 @@ private void addDefaultTasks(final BatchUploader uploader, final long parentIden`
`117`	`117`	`for (int taskIndex = 0; taskIndex < NUMBER_TASKS; taskIndex++)`
`118`	`118`	`{`
`119`	`119`	`uploader.addTask(newChallenge, this.getDefaultTask(-1, "Task" + taskIndex));`
`120`		`- LOG.debug("Added task name=Task{} parentId={} challengeName={}", taskIndex, parentIdentifier, newChallenge.getName());`
	`120`	`+ LOG.debug("Added task name=Task{} parentId={} challengeName={}", taskIndex,`
	`121`	`+ parentIdentifier, newChallenge.getName());`
`121`	`122`	`}`
`122`	`123`	`}`
`123`	`124`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,13 @@`
`1`	`1`	`package org.maproulette.client.model;`
`2`	`2`
	`3`	`+import java.io.IOException;`
	`4`	`+import java.io.Serializable;`
	`5`	`+import java.util.ArrayList;`
	`6`	`+import java.util.List;`
	`7`	`+`
	`8`	`+import org.maproulette.client.exception.MapRouletteRuntimeException;`
	`9`	`+import org.maproulette.client.utilities.ObjectMapperSingleton;`
	`10`	`+`
`3`	`11`	`import com.fasterxml.jackson.annotation.JsonValue;`
`4`	`12`	`import com.fasterxml.jackson.core.JsonGenerator;`
`5`	`13`	`import com.fasterxml.jackson.core.JsonParser;`
`@@ -11,17 +19,11 @@`
`11`	`19`	`import com.fasterxml.jackson.databind.annotation.JsonSerialize;`
`12`	`20`	`import com.fasterxml.jackson.databind.deser.std.StdDeserializer;`
`13`	`21`	`import com.fasterxml.jackson.databind.ser.std.StdSerializer;`
	`22`	`+`
`14`	`23`	`import lombok.AllArgsConstructor;`
`15`	`24`	`import lombok.Builder;`
`16`	`25`	`import lombok.Data;`
`17`	`26`	`import lombok.NoArgsConstructor;`
`18`		`-import org.maproulette.client.exception.MapRouletteRuntimeException;`
`19`		`-import org.maproulette.client.utilities.ObjectMapperSingleton;`
`20`		`-`
`21`		`-import java.io.IOException;`
`22`		`-import java.io.Serializable;`
`23`		`-import java.util.ArrayList;`
`24`		`-import java.util.List;`
`25`	`27`
`26`	`28`	`/**`
`27`	`29`	`* @author mcuthbert`
`@@ -53,44 +55,48 @@ public String toJson()`
`53`	`55`	`try`
`54`	`56`	`{`
`55`	`57`	`return ObjectMapperSingleton.getMapper().writeValueAsString(this);`
`56`		`- } catch (final JsonProcessingException e)`
	`58`	`+ }`
	`59`	`+ catch (final JsonProcessingException e)`
`57`	`60`	`{`
`58`	`61`	`throw new MapRouletteRuntimeException(e);`
`59`	`62`	`}`
`60`	`63`	`}`
`61`	`64`
	`65`	`+ /**`
	`66`	`+ * Serialize a {@code RuleList}`
	`67`	`+ */`
`62`	`68`	`public static class RuleListSerializer extends StdSerializer<RuleList>`
`63`	`69`	`{`
`64`		`-`
`65`	`70`	`public RuleListSerializer()`
`66`	`71`	`{`
`67`	`72`	`this(null);`
`68`	`73`	`}`
`69`	`74`
`70`		`- public RuleListSerializer(Class<RuleList> t)`
	`75`	`+ public RuleListSerializer(final Class<RuleList> clazzRuleList)`
`71`	`76`	`{`
`72`		`- super(t);`
	`77`	`+ super(clazzRuleList);`
`73`	`78`	`}`
`74`	`79`
`75`		`- private static void serializeRuleListHelper(List<RuleList> ruleList, JsonGenerator gen) throws IOException`
	`80`	`+ private static void serializeRuleListHelper(final List<RuleList> ruleListList,`
	`81`	`+ final JsonGenerator gen) throws IOException`
`76`	`82`	`{`
`77`		`- for (RuleList r : ruleList)`
	`83`	`+ for (final RuleList ruleList : ruleListList)`
`78`	`84`	`{`
`79`	`85`	`gen.writeStartObject();`
`80`		`- gen.writeStringField("condition", r.getCondition());`
	`86`	`+ gen.writeStringField("condition", ruleList.getCondition());`
`81`	`87`	`gen.writeArrayFieldStart("rules");`
`82`		`- if (r.getRuleList() != null)`
	`88`	`+ if (ruleList.getRuleList() != null)`
`83`	`89`	`{`
`84`		`- for (RuleList it : r.getRuleList())`
	`90`	`+ for (final RuleList nestedRuleList : ruleList.getRuleList())`
`85`	`91`	`{`
`86`		`- serializeRuleListHelper(it.getRuleList(), gen);`
	`92`	`+ serializeRuleListHelper(nestedRuleList.getRuleList(), gen);`
`87`	`93`	`}`
`88`	`94`	`}`
`89`		`- if (r.getRules() != null)`
	`95`	`+ if (ruleList.getRules() != null)`
`90`	`96`	`{`
`91`		`- for (PriorityRule p : r.getRules())`
	`97`	`+ for (final PriorityRule priorityRule : ruleList.getRules())`
`92`	`98`	`{`
`93`		`- gen.writeObject(p);`
	`99`	`+ gen.writeObject(priorityRule);`
`94`	`100`	`}`
`95`	`101`	`}`
`96`	`102`	`gen.writeEndArray();`
`@@ -99,7 +105,8 @@ private static void serializeRuleListHelper(List<RuleList> ruleList, JsonGenerat`
`99`	`105`	`}`
`100`	`106`
`101`	`107`	`@Override`
`102`		`- public void serialize(RuleList value, JsonGenerator gen, SerializerProvider serializers) throws IOException`
	`108`	`+ public void serialize(final RuleList value, final JsonGenerator gen,`
	`109`	`+ final SerializerProvider serializers) throws IOException`
`103`	`110`	`{`
`104`	`111`	`gen.writeStartObject();`
`105`	`112`	`gen.writeStringField("condition", value.getCondition());`
`@@ -111,55 +118,56 @@ public void serialize(RuleList value, JsonGenerator gen, SerializerProvider seri`
`111`	`118`
`112`	`119`	`if (value.getRules() != null)`
`113`	`120`	`{`
`114`		`- for (PriorityRule p : value.getRules())`
	`121`	`+ for (final PriorityRule priorityRule : value.getRules())`
`115`	`122`	`{`
`116`		`- gen.writeObject(p);`
	`123`	`+ gen.writeObject(priorityRule);`
`117`	`124`	`}`
`118`	`125`	`}`
`119`	`126`	`gen.writeEndArray();`
`120`	`127`	`gen.writeEndObject();`
`121`	`128`	`}`
`122`	`129`	`}`
`123`	`130`
	`131`	`+ /**`
	`132`	`+ * Deserialize a {@code RuleList}`
	`133`	`+ */`
`124`	`134`	`public static class RuleListDeserializer extends StdDeserializer<RuleList>`
`125`	`135`	`{`
`126`		`-`
`127`	`136`	`public RuleListDeserializer()`
`128`	`137`	`{`
`129`	`138`	`this(null);`
`130`	`139`	`}`
`131`	`140`
`132`		`- public RuleListDeserializer(final Class<?> vc)`
	`141`	`+ public RuleListDeserializer(final Class<?> valueClass)`
`133`	`142`	`{`
`134`		`- super(vc);`
	`143`	`+ super(valueClass);`
`135`	`144`	`}`
`136`	`145`
`137`		`- private static RuleList buildRuleListHelper(JsonNode node, DeserializationContext ctxt)`
	`146`	`+ private static RuleList buildRuleListHelper(final JsonNode node,`
	`147`	`+ final DeserializationContext ctxt)`
`138`	`148`	`{`
`139`	`149`	`if (node.get("condition") == null)`
`140`	`150`	`{`
`141`	`151`	`return null;`
`142`	`152`	`}`
`143`		`- final RuleList ret = RuleList.builder()`
`144`		`- .condition(node.get("condition").asText())`
`145`		`- .ruleList(new ArrayList<>())`
`146`		`- .rules(new ArrayList<>())`
`147`		`- .build();`
	`153`	`+ final RuleList ret = RuleList.builder().condition(node.get("condition").asText())`
	`154`	`+ .ruleList(new ArrayList<>()).rules(new ArrayList<>()).build();`
`148`	`155`
`149`		`- for (JsonNode it : node.withArray("rules"))`
	`156`	`+ for (final JsonNode jsonNode : node.withArray("rules"))`
`150`	`157`	`{`
`151`		`- if (it.get("condition") != null)`
	`158`	`+ if (jsonNode.get("condition") != null)`
`152`	`159`	`{`
`153`		`- // If the child is a PriorityRule, do a recursive call to build the rule and add it to the list.`
`154`		`- RuleList child = buildRuleListHelper(it, ctxt);`
	`160`	`+ // If the child is a PriorityRule, do a recursive call to build the rule and add`
	`161`	`+ // it to the list.`
	`162`	`+ final RuleList child = buildRuleListHelper(jsonNode, ctxt);`
`155`	`163`	`ret.getRuleList().add(child);`
`156`		`- } else`
	`164`	`+ }`
	`165`	`+ else`
`157`	`166`	`{`
`158`		`- PriorityRule priorityRule = PriorityRule.builder()`
`159`		`- .type(it.get("type").asText())`
`160`		`- .operator(it.get("operator").asText())`
`161`		`- .value(it.get("value").asText())`
`162`		`- .build();`
	`167`	`+ final PriorityRule priorityRule = PriorityRule.builder()`
	`168`	`+ .type(jsonNode.get("type").asText())`
	`169`	`+ .operator(jsonNode.get("operator").asText())`
	`170`	`+ .value(jsonNode.get("value").asText()).build();`
`163`	`171`	`ret.getRules().add(priorityRule);`
`164`	`172`	`}`
`165`	`173`	`}`
`@@ -168,9 +176,10 @@ private static RuleList buildRuleListHelper(JsonNode node, DeserializationContex`
`168`	`176`	`}`
`169`	`177`
`170`	`178`	`@Override`
`171`		`- public RuleList deserialize(JsonParser p, DeserializationContext ctxt) throws IOException`
	`179`	`+ public RuleList deserialize(final JsonParser jsonParser, final DeserializationContext ctxt)`
	`180`	`+ throws IOException`
`172`	`181`	`{`
`173`		`- JsonNode node = p.getCodec().readTree(p);`
	`182`	`+ final JsonNode node = jsonParser.getCodec().readTree(jsonParser);`
`174`	`183`	`return buildRuleListHelper(node, ctxt);`
`175`	`184`	`}`
`176`	`185`	`}`