could this be pulled up into the specific SettingOption implementation referenced above? I'd like to avoid an ever-growing if chain. If we do leave the implementation here, perhaps a switch statement would be more efficient and read more clearly?

Moved to switch, thanks.

Thoughts:

While it might be a little more straight-forward here to just mirror our ruby setting in java-land, I think we have the opportunity to introduce a path toward safety.

In the end, I would prefer to have a collection of Setting objects that are immutable at runtime so that we can ensure that once they are initialized they are not modified. This will be especially useful as it will reduce the surface-area for bugs caused by plugins that reside in other code-bases modifying settings that they do not wholly own.

To achieve this, I think we need a few tweaks to the abstraction.

• Introduce java SettingOption, an immutable object representing a single configurable setting name along with its defaults, validators, etc., but not the value.
• Introduce java Setting, an immutable object representing the current effective value of the setting and the information about whether that value was explicitly given or implicit. Implementation will likely carry a reference to a specific SettingOption instance.
• Ruby Setting remains mutable, but as a wrapper for the immutable java Setting.
  • Its mutation methods (e.g., Setting#set(value), Setting#reset(value)) replace the reference to the new java Setting.
  • Its mutation methods emit a deprecation log once the settings have been parsed from config and/or command-line. This will likely be implemented as a global variable that gets set once the config has been loaded.
  • This bit could be implemented in vanilla ruby or in a jruby java extension.

This will enable us to independently move setting initialization into java at a later time, and to subsequently remove the mutation methods from the ruby shim in a future major release.

This PR is POC to move the head of settings hierarchy (the Setting class) from Ruby to Java. The idea is to create an isolation level (SettingExt + ProxyJavaSetting classes) to keep the 2 world separated to that we can try to improve the implementation on the Java side without affecting too much the Ruby one. Your idea to use value objects is great this saves from various side effects, however do we really have plugins that manipulate core settings?

@yaauie I've a couple of questions.

• what do you mean for "whether that value was explicitly given or implicit."? Is implicit the value of the setting passed at construction time while the explicit is the one provided to the set method?
• if we think to use the existing Ruby Setting class as a container of the Java Setting (+ SettingOption) then we don't have any reason to create a JRuby extension for the root class Setting like this PR is doing, right?

nit: debuging to stdout