#372 Extract path methods from PropertyReader, rename "key" to "path"

Author: ljacqu

src/main/java/ch/jalu/configme/resource/PathProvider.java

@@ -0,0 +1,55 @@
+package ch.jalu.configme.resource;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Set;
+
+/**
+ * Exposes the paths available in a configuration resource.
+ * <p>
+ * This interface is an optional extension for {@link PropertyReader} implementations that support path enumeration.
+ */
+public interface PathProvider {
+
+    /**
+     * Returns all paths available in the resource, including intermediate paths.
+     * <p>
+     * For a configuration like:
+     * <pre>
+     * header:
+     *   title: Hello
+     *   font:
+     *     color: red
+     *     size: 12
+     * </pre>
+     * this method returns {@code ["header", "header.title", "header.font", "header.font.color", "header.font.size"]}.
+     *
+     * @return all paths (in encounter order)
+     */
+    @NotNull Set<String> getPaths();
+
+    /**
+     * Returns all leaf paths in the resource.
+     * <p>
+     * For the configuration example in {@link #getPaths()}, this method returns
+     * {@code ["header.title", "header.font.color", "header.font.size"]}.
+     *
+     * @return all leaf paths (in encounter order)
+     */
+    @NotNull Set<String> getLeafPaths();
+
+    /**
+     * Returns the direct child paths of the given path. Returns an empty set
+     * if the path does not exist or has no children.
+     * <p>
+     * For the configuration example in {@link #getPaths()},
+     * {@code getChildPaths("header")} returns {@code ["header.title", "header.font"]}.
+     * <p>
+     * If {@code path} is empty, the top-level paths are returned.
+     *
+     * @param path the path whose direct child paths should be looked up
+     * @return all direct child paths (in encounter order, never null)
+     */
+    @NotNull Set<String> getChildPaths(@NotNull String path);
+
+}

src/main/java/ch/jalu/configme/resource/PropertyReader.java

@@ -9,7 +9,6 @@
 import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
-import java.util.Set;
 
 /**
  * A property reader provides values from a resource (e.g. a YAML file) based on whose data the values of properties
@@ -37,24 +36,6 @@ public interface PropertyReader {
      */
     @Nullable Object getValue(@NotNull String path);
 
-    /**
-     * Returns the keys available in the file. Depending on the parameter either all keys are returned,
-     * or only the keys of the leaf nodes are considered.
-     *
-     * @param onlyLeafNodes true if only the paths of leaf nodes should be returned (no intermediate paths)
-     * @return set of all existing keys (ordered)
-     */
-    @NotNull Set<String> getKeys(boolean onlyLeafNodes);
-
-    /**
-     * Returns the direct children of the given path which are available in the file. Returns an empty set
-     * if the path does not exist in the file (never null).
-     *
-     * @param path the path whose direct child paths should be looked up
-     * @return set of all direct children (ordered, never null)
-     */
-    @NotNull Set<String> getChildKeys(@NotNull String path);
-
     /**
      * Returns the object at the given path, or null if absent.
      *

src/main/java/ch/jalu/configme/resource/YamlFileReader.java

@@ -23,7 +23,7 @@
 /**
  * YAML file reader.
  */
-public class YamlFileReader implements PropertyReader {
+public class YamlFileReader implements PropertyReader, PathProvider {
 
     private final Path path;
     private final Charset charset;
@@ -74,17 +74,17 @@ public boolean contains(@NotNull String path) {
     }
 
     @Override
-    public @NotNull Set<String> getKeys(boolean onlyLeafNodes) {
-        if (root == null) {
-            return Collections.emptySet();
-        }
-        Set<String> allKeys = new LinkedHashSet<>();
-        collectKeysIntoSet("", root, allKeys, onlyLeafNodes);
-        return allKeys;
+    public @NotNull Set<String> getPaths() {
+        return collectPaths(false);
+    }
+
+    @Override
+    public @NotNull Set<String> getLeafPaths() {
+        return collectPaths(true);
     }
 
     @Override
-    public @NotNull Set<String> getChildKeys(@NotNull String path) {
+    public @NotNull Set<String> getChildPaths(@NotNull String path) {
         Object object = getValue(path);
         if (object instanceof Map) {
             String pathPrefix = path.isEmpty() ? "" : path + ".";
@@ -95,6 +95,15 @@ public boolean contains(@NotNull String path) {
         return Collections.emptySet();
     }
 
+    private @NotNull Set<String> collectPaths(boolean onlyLeafNodes) {
+        if (root == null) {
+            return Collections.emptySet();
+        }
+        Set<String> allKeys = new LinkedHashSet<>();
+        collectKeysIntoSet("", root, allKeys, onlyLeafNodes);
+        return allKeys;
+    }
+
     /**
      * Recursively collects keys from maps into the given set.
      *
@@ -103,8 +112,8 @@ public boolean contains(@NotNull String path) {
      * @param result set to save keys to
      * @param onlyLeafNodes whether only leaf nodes should be added to the result set
      */
-    private void collectKeysIntoSet(@NotNull String path, @NotNull Map<String, Object> map, @NotNull Set<String> result,
-                                    boolean onlyLeafNodes) {
+    private static void collectKeysIntoSet(@NotNull String path, @NotNull Map<String, Object> map,
+                                           @NotNull Set<String> result, boolean onlyLeafNodes) {
         for (Map.Entry<String, Object> entry : map.entrySet()) {
             String childPath = PathUtils.concat(path, entry.getKey());
             if (!onlyLeafNodes || isLeafValue(entry.getValue())) {

src/test/java/ch/jalu/configme/resource/YamlFileReaderTest.java

@@ -204,8 +204,8 @@ void shouldHandleEmptyFile() {
         // then
         assertThat(result, sameInstance(configFile));
         assertThat(reader.getRoot(), nullValue());
-        assertThat(reader.getKeys(true), empty());
-        assertThat(reader.getChildKeys(""), empty());
+        assertThat(reader.getLeafPaths(), empty());
+        assertThat(reader.getChildPaths(""), empty());
     }
 
     @Test
@@ -232,16 +232,16 @@ void shouldReadWithCustomCharset() {
     }
 
     @Test
-    void shouldReturnKeysOfFile() {
+    void shouldReturnPathsOfFile() {
         // given
         Path file = copyFileFromResources(COMPLETE_FILE);
         YamlFileReader reader = new YamlFileReader(file);
 
         // when
-        Set<String> keys = reader.getKeys(false);
+        Set<String> paths = reader.getPaths();
 
         // then
-        assertThat(keys, contains("test", "test.duration", "test.systemName",
+        assertThat(paths, contains("test", "test.duration", "test.systemName",
             "sample", "sample.ratio", "sample.ratio.order", "sample.ratio.fields",
             "version",
             "features", "features.boring", "features.boring.skip", "features.boring.colors", "features.boring.dustLevel",
@@ -250,16 +250,16 @@ void shouldReturnKeysOfFile() {
     }
 
     @Test
-    void shouldReturnLeafNodeKeysInFile() {
+    void shouldReturnLeafPathsInFile() {
         // given
         Path file = copyFileFromResources(COMPLETE_FILE);
         YamlFileReader reader = new YamlFileReader(file);
 
         // when
-        Set<String> keys = reader.getKeys(true);
+        Set<String> paths = reader.getLeafPaths();
 
         // then
-        assertThat(keys, contains("test.duration", "test.systemName",
+        assertThat(paths, contains("test.duration", "test.systemName",
             "sample.ratio.order", "sample.ratio.fields",
             "version",
             "features.boring.skip", "features.boring.colors", "features.boring.dustLevel",
@@ -274,11 +274,11 @@ void shouldTreatEmptyMapsAsLeafNodes() {
         YamlFileReader reader = new YamlFileReader(file);
 
         // when
-        Set<String> keys = reader.getKeys(true);
+        Set<String> paths = reader.getLeafPaths();
 
         // then
-        assertThat(keys, hasSize(24));
-        assertThat(keys, hasItems(
+        assertThat(paths, hasSize(24));
+        assertThat(paths, hasItems(
             "message-key.conditionalElem.conditionals.low.conditionals", // empty map
             "message-key.conditionalElem.conditionals.med.color",
             "message-key.conditionalElem.conditionals.high.conditionalElem.bold",
@@ -290,29 +290,29 @@ void shouldTreatEmptyMapsAsLeafNodes() {
     }
 
     @Test
-    void shouldReturnChildrenPathsOfGivenPath() {
+    void shouldReturnChildPathsOfGivenPath() {
         // given
         Path file = copyFileFromResources(COMPLETE_FILE);
         YamlFileReader reader = new YamlFileReader(file);
 
         // when
-        Set<String> keys = reader.getChildKeys("features.boring");
+        Set<String> paths = reader.getChildPaths("features.boring");
 
         // then
-        assertThat(keys, contains("features.boring.skip", "features.boring.colors", "features.boring.dustLevel"));
+        assertThat(paths, contains("features.boring.skip", "features.boring.colors", "features.boring.dustLevel"));
     }
 
     @Test
-    void shouldReturnChildrenPathsOfRoot() {
+    void shouldReturnChildPathsOfRoot() {
         // given
         Path file = copyFileFromResources(COMPLETE_FILE);
         YamlFileReader reader = new YamlFileReader(file);
 
         // when
-        Set<String> keys = reader.getChildKeys("");
+        Set<String> paths = reader.getChildPaths("");
 
         // then
-        assertThat(keys, contains("test", "sample", "version", "features", "security"));
+        assertThat(paths, contains("test", "sample", "version", "features", "security"));
     }
 
     @Test
@@ -322,8 +322,8 @@ void shouldReturnEmptySetForNonExistentOrLeafValue() {
         YamlFileReader reader = new YamlFileReader(file);
 
         // when
-        Set<String> bogusChildren = reader.getChildKeys("bogus");
-        Set<String> leafChildren = reader.getChildKeys("features.boring.colors");
+        Set<String> bogusChildren = reader.getChildPaths("bogus");
+        Set<String> leafChildren = reader.getChildPaths("features.boring.colors");
 
         // then
         assertThat(bogusChildren, empty());