Rework FileSystemOptions data object (#2638)

Signed-off-by: Julien Viet <julien@julienviet.com>

src/main/asciidoc/dataobjects.adoc

@@ -584,8 +584,14 @@ Set whether Netty pooled buffers are enabled
 [frame="topbot"]
 |===
 ^|Name | Type ^| Description
-|[[classPathResolvingEnabled]]`@classPathResolvingEnabled`|`Boolean`|-
-|[[fileResolverCachingEnabled]]`@fileResolverCachingEnabled`|`Boolean`|-
+|[[classPathResolvingEnabled]]`@classPathResolvingEnabled`|`Boolean`|+++
+When vert.x cannot find the file on the filesystem it tries to resolve the
+ file from the class path when this is set to <code>true</code>.
++++
+|[[fileCachingEnabled]]`@fileCachingEnabled`|`Boolean`|+++
+Set to <code>true</code> to cache files on the real file system
+ when the filesystem performs class path resolving.
++++
 |===
 
 [[GoAway]]

src/main/asciidoc/filesystem.adoc

@@ -137,12 +137,12 @@ a `/`.
 Due to the fact that Java does not offer async access to classpath
 resources, the file is copied to the filesystem in a worker thread when the
 classpath resource is accessed the very first time and served from there
-asynchrously. When the same resource is accessed a second time, the file from
+asynchronously. When the same resource is accessed a second time, the file from
 the filesystem is served directly from the filesystem. The original content
 is served even if the classpath resource changes (e.g. in a development
 system).
 
-This caching behaviour can be set on the {@link io.vertx.core.file.FileSystemOptions#setFileResolverCachingEnabled(boolean)}
+This caching behaviour can be set on the {@link io.vertx.core.file.FileSystemOptions#setFileCachingEnabled(boolean)}
 option. The default value of this option is `true` unless the system property `vertx.disableFileCaching` is
 defined.
 

src/main/generated/io/vertx/core/file/FileSystemOptionsConverter.java

@@ -19,9 +19,9 @@ static void fromJson(Iterable<java.util.Map.Entry<String, Object>> json, FileSys
             obj.setClassPathResolvingEnabled((Boolean)member.getValue());
           }
           break;
-        case "fileResolverCachingEnabled":
+        case "fileCachingEnabled":
           if (member.getValue() instanceof Boolean) {
-            obj.setFileResolverCachingEnabled((Boolean)member.getValue());
+            obj.setFileCachingEnabled((Boolean)member.getValue());
           }
           break;
       }
@@ -34,6 +34,6 @@ static void toJson(FileSystemOptions obj, JsonObject json) {
 
    static void toJson(FileSystemOptions obj, java.util.Map<String, Object> json) {
     json.put("classPathResolvingEnabled", obj.isClassPathResolvingEnabled());
-    json.put("fileResolverCachingEnabled", obj.isFileResolverCachingEnabled());
+    json.put("fileCachingEnabled", obj.isFileCachingEnabled());
   }
 }

src/main/java/io/vertx/core/VertxOptions.java

@@ -726,7 +726,7 @@ public boolean isFileResolverCachingEnabled() {
     if (fileSystemOptions == null) {
       return DEFAULT_FILE_CACHING_ENABLED;
     }
-    return fileSystemOptions.isFileResolverCachingEnabled();
+    return fileSystemOptions.isFileCachingEnabled();
   }
 
   /**
@@ -742,7 +742,7 @@ public VertxOptions setFileResolverCachingEnabled(boolean fileResolverCachingEna
     if (fileSystemOptions == null) {
       fileSystemOptions = new FileSystemOptions();
     }
-    this.fileSystemOptions.setFileResolverCachingEnabled(fileResolverCachingEnabled);
+    this.fileSystemOptions.setFileCachingEnabled(fileResolverCachingEnabled);
     return this;
   }
 

src/main/java/io/vertx/core/file/FileSystemOptions.java

@@ -21,15 +21,22 @@
 /**
  * Vert.x file system base configuration, this class can be extended by provider implementations to configure
  * those specific implementations.
- *
  */
 @DataObject(generateConverter = true, publicConverter = false)
 public class FileSystemOptions {
+
+  /**
+   * The default behavior for caching files for class path resolution = {@code false} if and only if the system property {@code "vertx.disableFileCaching"} exists and is set to the string {@code "false"}
+   */
   public static final boolean DEFAULT_FILE_CACHING_ENABLED = !Boolean.getBoolean(DISABLE_FILE_CACHING_PROP_NAME);
+
+  /**
+   * The default behavior to cache or not class path resolution = {@code false} if and only if the system property {@code "vertx.disableFileCPResolving"} exists and is set to the string {@code "false"}
+   */
   public static final boolean DEFAULT_CLASS_PATH_RESOLVING_ENABLED = !Boolean.getBoolean(DISABLE_CP_RESOLVING_PROP_NAME);
 
   private boolean classPathResolvingEnabled = DEFAULT_CLASS_PATH_RESOLVING_ENABLED;
-  private boolean fileResolverCachingEnabled = DEFAULT_FILE_CACHING_ENABLED;
+  private boolean fileCachingEnabled = DEFAULT_FILE_CACHING_ENABLED;
 
   /**
    * Default constructor
@@ -44,7 +51,7 @@ public FileSystemOptions() {
    */
   public FileSystemOptions(FileSystemOptions other) {
     this.classPathResolvingEnabled = other.isClassPathResolvingEnabled();
-    this.fileResolverCachingEnabled = other.isFileResolverCachingEnabled();
+    this.fileCachingEnabled = other.isFileCachingEnabled();
   }
 
   /**
@@ -70,21 +77,41 @@ public JsonObject toJson() {
     return json;
   }
 
+  /**
+   * @return whether classpath resolving is enabled
+   */
   public boolean isClassPathResolvingEnabled() {
     return this.classPathResolvingEnabled;
   }
 
-  public boolean isFileResolverCachingEnabled() {
-    return this.fileResolverCachingEnabled;
-  }
-
+  /**
+   * When vert.x cannot find the file on the filesystem it tries to resolve the
+   * file from the class path when this is set to {@code true}.
+   *
+   * @param classPathResolvingEnabled the value
+   * @return a reference to this, so the API can be used fluently
+   */
   public FileSystemOptions setClassPathResolvingEnabled(boolean classPathResolvingEnabled) {
     this.classPathResolvingEnabled = classPathResolvingEnabled;
     return this;
   }
 
-  public FileSystemOptions setFileResolverCachingEnabled(boolean fileResolverCachingEnabled) {
-    this.fileResolverCachingEnabled = fileResolverCachingEnabled;
+  /**
+   * @return whether file caching is enabled for class path resolving
+   */
+  public boolean isFileCachingEnabled() {
+    return this.fileCachingEnabled;
+  }
+
+  /**
+   * Set to {@code true} to cache files on the real file system
+   * when the filesystem performs class path resolving.
+   *
+   * @param fileCachingEnabled the value
+   * @return a reference to this, so the API can be used fluently
+   */
+  public FileSystemOptions setFileCachingEnabled(boolean fileCachingEnabled) {
+    this.fileCachingEnabled = fileCachingEnabled;
     return this;
   }
 
@@ -96,22 +123,21 @@ public boolean equals(Object o) {
     FileSystemOptions that = (FileSystemOptions) o;
 
     if (classPathResolvingEnabled != that.isClassPathResolvingEnabled()) return false;
-    return fileResolverCachingEnabled == that.isFileResolverCachingEnabled();
+    return fileCachingEnabled == that.isFileCachingEnabled();
   }
 
   @Override
   public int hashCode() {
     int result = (classPathResolvingEnabled ? 1 : 0);
-    result += (fileResolverCachingEnabled ? 1 : 0);
+    result += (fileCachingEnabled ? 1 : 0);
     return 31 * result;
   }
 
   @Override
   public String toString() {
     return "FileSystemOptions{" +
     "classPathResolvingEnabled=" + classPathResolvingEnabled +
-    ", fileResolverCachingEnabled=" + fileResolverCachingEnabled +
+    ", fileCachingEnabled=" + fileCachingEnabled +
     '}';
   }
-
 }

src/main/java/io/vertx/core/file/impl/FileResolver.java

@@ -13,7 +13,6 @@
 
 import io.vertx.core.VertxException;
 import io.vertx.core.file.FileSystemOptions;
-import io.vertx.core.VertxOptions;
 
 import java.io.Closeable;
 import java.io.File;
@@ -72,11 +71,11 @@ public FileResolver() {
   }
 
   public FileResolver(boolean enableCaching) {
-    this(new FileSystemOptions().setFileResolverCachingEnabled(enableCaching));
+    this(new FileSystemOptions().setFileCachingEnabled(enableCaching));
   }
 
   public FileResolver(FileSystemOptions fileSystemOptions) {
-    this.enableCaching = fileSystemOptions.isFileResolverCachingEnabled();
+    this.enableCaching = fileSystemOptions.isFileCachingEnabled();
     this.enableCpResolving = fileSystemOptions.isClassPathResolvingEnabled();
     String cwdOverride = System.getProperty("vertx.cwd");
     if (cwdOverride != null) {

src/test/java/io/vertx/core/VertxOptionsTest.java

@@ -11,7 +11,6 @@
 
 package io.vertx.core;
 
-import io.vertx.core.VertxOptions;
 import io.vertx.core.file.FileSystemOptions;
 import io.vertx.core.json.JsonObject;
 import io.vertx.core.metrics.MetricsOptions;
@@ -388,7 +387,7 @@ public void testJsonOptions() {
         put("warningExceptionTime", warningExceptionTime).
         put("fileSystemOptions", new JsonObject().
             put("classPathResolvingEnabled", classPathResolvingEnabled).
-            put("fileResolverCachingEnabled", fileResolverCachingEnabled)).
+            put("fileCachingEnabled", fileResolverCachingEnabled)).
         put("metricsOptions", new JsonObject().
             put("enabled", metricsEnabled).
             put("jmxEnabled", jmxEnabled).
@@ -417,7 +416,7 @@ public void testJsonOptions() {
     assertEquals(haGroup, options.getHAGroup());
     FileSystemOptions fileSystemOptions = options.getFileSystemOptions();
     assertEquals(classPathResolvingEnabled, fileSystemOptions.isClassPathResolvingEnabled());
-    assertEquals(fileResolverCachingEnabled, fileSystemOptions.isFileResolverCachingEnabled());
+    assertEquals(fileResolverCachingEnabled, fileSystemOptions.isFileCachingEnabled());
     MetricsOptions metricsOptions = options.getMetricsOptions();
     assertEquals(metricsEnabled, metricsOptions.isEnabled());
     assertEquals(warningExceptionTime, options.getWarningExceptionTime());

src/test/java/io/vertx/core/file/FileSystemOptionsTest.java

@@ -11,7 +11,6 @@
 
 package io.vertx.core.file;
 
-import io.vertx.core.file.FileSystemOptions;
 import io.vertx.core.json.JsonObject;
 import io.vertx.test.core.VertxTestBase;
 import org.junit.Test;
@@ -23,7 +22,7 @@ public class FileSystemOptionsTest extends VertxTestBase {
   public void testDefaults() {
     FileSystemOptions options = new FileSystemOptions();
 
-    assertTrue(options.isFileResolverCachingEnabled());
+    assertTrue(options.isFileCachingEnabled());
     assertTrue(options.isClassPathResolvingEnabled());
   }
 
@@ -33,17 +32,17 @@ public void testCopy() {
 
     Random rand = new Random();
     boolean enabled = rand.nextBoolean();
-    options.setFileResolverCachingEnabled(enabled);
+    options.setFileCachingEnabled(enabled);
     options.setClassPathResolvingEnabled(enabled);
     options = new FileSystemOptions(options);
     assertEquals(enabled, options.isClassPathResolvingEnabled());
-    assertEquals(enabled, options.isFileResolverCachingEnabled());
+    assertEquals(enabled, options.isFileCachingEnabled());
   }
 
   @Test
   public void testEmptyJsonOptions() {
     FileSystemOptions options = new FileSystemOptions(new JsonObject());
-    assertTrue(options.isFileResolverCachingEnabled());
+    assertTrue(options.isFileCachingEnabled());
     assertTrue(options.isClassPathResolvingEnabled());
   }
 
@@ -52,11 +51,11 @@ public void testJsonOptions() {
     Random rand = new Random();
     boolean enabled = rand.nextBoolean();
     FileSystemOptions options = new FileSystemOptions(new JsonObject().
-      put("fileResolverCachingEnabled", enabled).
+      put("fileCachingEnabled", enabled).
       put("classPathResolvingEnabled", enabled)
     );
-    assertEquals(enabled, options.isFileResolverCachingEnabled());
-    assertEquals(enabled, options.toJson().getBoolean("fileResolverCachingEnabled"));
+    assertEquals(enabled, options.isFileCachingEnabled());
+    assertEquals(enabled, options.toJson().getBoolean("fileCachingEnabled"));
     assertEquals(enabled, options.isClassPathResolvingEnabled());
     assertEquals(enabled, options.toJson().getBoolean("classPathResolvingEnabled"));
   }