Save work

Services.contains(Class<?>) to implement an alternative to GlobalConfig.configured()
Fix copyright
Fix checktyle

micronaut tests shouldn't run during the build

Save work

Add package private constructor for ConfigRef

restore CoreServiceRegistry

Author: romain-grecourt

common/config/src/main/java/io/helidon/common/config/Config.java

@@ -29,6 +29,7 @@
  * @deprecated use {@code io.helidon.config.Config} instead
  */
 @Deprecated(forRemoval = true, since = "4.3.0")
+@SuppressWarnings("removal")
 public interface Config {
     /**
      * Empty instance of {@code Config}.
@@ -47,7 +48,7 @@ static Config empty() {
      * @return a new configuration
      */
     static Config create() {
-        return GlobalConfig.create();
+        return ConfigFactory.createDefault();
     }
 
     /**
@@ -69,12 +70,11 @@ static Config create() {
      * <p>
      * The name of a node is the last token in its fully-qualified key.
      * <p>
-     * The exact format of the name depends on the {@code Type} of the
-     * containing node:
+     * The exact format of the name depends on the type of the containing node:
      * <ul>
-     * <li>from a Type#OBJECT node the token for a child is the
+     * <li>from an "object" node the token for a child is the
      * <strong>name of the object member</strong>;</li>
-     * <li>from a Type#LIST node the token for a child is a zero-based
+     * <li>from a "list" node the token for a child is a zero-based
      * <strong>index of the element</strong>, an unsigned base-10 integer value
      * with no leading zeros.</li>
      * </ul>
@@ -206,25 +206,25 @@ default Config get(Key key) {
     boolean isLeaf();
 
     /**
-     * Returns {@code true} if this node exists and is Type#Object.
+     * Returns {@code true} if this node exists and is an "object" node.
      *
-     * @return {@code true} if the node exists and is Type#Object, {@code false}
+     * @return {@code true} if the node exists and is an "object" node, {@code false}
      *         otherwise.
      */
     boolean isObject();
 
     /**
-     * Returns {@code true} if this node exists and is Type#List.
+     * Returns {@code true} if this node exists and is a "list" node.
      *
-     * @return {@code true} if the node exists and is Type#List, {@code false}
+     * @return {@code true} if the node exists and is a "list" node, {@code false}
      *         otherwise.
      */
     boolean isList();
 
     /**
      * Returns {@code true} if this configuration node has a direct value.
      * <p>
-     * This may be a value node (e.g. a leaf) or object node or a list node
+     * This may be a "value" node (e.g. a leaf) or "object" node or a "list" node
      * (e.g. a branch with value). The application can invoke methods such as
      * {@link #as(Class)} on nodes that have value.
      *
@@ -274,30 +274,30 @@ default Config get(Key key) {
     /**
      * Returns this node as a list mapping each list value using the provided mapper.
      *
-     * @param mapper mapper to convert each list node into a typed value
+     * @param mapper mapper to convert each "list" node into a typed value
      * @param <T>    type of list elements
      * @return a typed list with values
      * @throws io.helidon.common.config.ConfigException in case the mapper fails to map the values
      */
     <T> ConfigValue<List<T>> mapList(Function<Config, T> mapper) throws ConfigException;
 
     /**
-     * Returns a list of child {@code Config} nodes if the node is {@code Type#OBJECT}.
-     * Returns a list of element nodes if the node is {@code Type#LIST}.
-     * Throws {@code MissingValueException} if the node is {@code Type#MISSING}.
-     * Otherwise, if node is {@code Type#VALUE}, it throws {@code ConfigMappingException}.
+     * Returns a list of child {@code Config} nodes if the node is an "object" node.
+     * Returns a list of element nodes if the node is a "list" node.
+     * Throws {@code MissingValueException} if the node is a missing node.
+     * Otherwise, if the node is a "value" node, it throws {@code ConfigMappingException}.
      *
-     * @return a list of {@code Type#OBJECT} members or a list of {@code Type#LIST} members
+     * @return a list of "object" node members or a list of "list" node members
      * @param <C> the common config derived type
-     * @throws io.helidon.common.config.ConfigException in case the node is {@code Type#VALUE}
+     * @throws io.helidon.common.config.ConfigException in case the node is a "value" node
      */
     <C extends Config> ConfigValue<List<C>> asNodeList() throws ConfigException;
 
     /**
      * Transform all leaf nodes (values) into Map instance.
      *
      * @return new Map instance that contains all config leaf node values
-     * @throws io.helidon.common.config.ConfigException in case the node is Type#MISSING.
+     * @throws io.helidon.common.config.ConfigException in case the node is a "missing" node.
      */
     ConfigValue<Map<String, String>> asMap() throws ConfigException;
 
@@ -363,8 +363,8 @@ default ConfigValue<Double> asDouble() {
      * Fully-qualified key is list of key tokens separated by {@code .} (dot character).
      * Depending on context the key token is evaluated one by one:
      * <ul>
-     * <li>in Type#OBJECT node the token represents a <strong>name of object member</strong>;</li>
-     * <li>in Type#LIST node the token represents an zero-based <strong>index of list
+     * <li>in "object" nodes the token represents a <strong>name of object member</strong>;</li>
+     * <li>in "list" nodes the token represents a zero-based <strong>index of list
      * element</strong>,
      * an unsigned base-10 integer value, leading zeros are not allowed.</li>
      * </ul>
@@ -445,9 +445,9 @@ static String unescapeName(String escapedName) {
          * The name of a node is the last token in fully-qualified key.
          * Depending on context the name is evaluated one by one:
          * <ul>
-         * <li>in Type#OBJECT} node the name represents a <strong>name of object member</strong>;
+         * <li>in "object" nodes the name represents a <strong>name of object member</strong>;
          * </li>
-         * <li>in Type#LIST} node the name represents an zero-based <strong>index of list
+         * <li>in "list" nodes the name represents a zero-based <strong>index of list
          * element</strong>,
          * an unsigned base-10 integer value, leading zeros are not allowed.</li>
          * </ul>
@@ -475,5 +475,4 @@ static String unescapeName(String escapedName) {
         Key child(Key key);
 
     }
-
 }

common/config/src/main/java/io/helidon/common/config/ConfigDelegate.java

@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) 2025 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.helidon.common.config;
+
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.Stream;
+
+/**
+ * Config delegate backed by a supplier.
+ */
+@SuppressWarnings("removal")
+final class ConfigDelegate implements Config {
+
+    private final Supplier<Config> delegate;
+
+    ConfigDelegate(Supplier<Config> delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public Key key() {
+        return delegate.get().key();
+    }
+
+    @Override
+    public String name() {
+        return delegate.get().name();
+    }
+
+    @Override
+    public Config get(String key) throws ConfigException {
+        return delegate.get().get(key);
+    }
+
+    @Override
+    public Config root() {
+        return delegate.get().root();
+    }
+
+    @Override
+    public Config get(Key key) {
+        return delegate.get().get(key);
+    }
+
+    @Override
+    public Config detach() throws ConfigException {
+        return delegate.get().detach();
+    }
+
+    @Override
+    public boolean exists() {
+        return delegate.get().exists();
+    }
+
+    @Override
+    public Stream<? extends Config> traverse() {
+        return delegate.get().traverse();
+    }
+
+    @Override
+    public boolean isLeaf() {
+        return delegate.get().isLeaf();
+    }
+
+    @Override
+    public boolean isObject() {
+        return delegate.get().isObject();
+    }
+
+    @Override
+    public boolean isList() {
+        return delegate.get().isList();
+    }
+
+    @Override
+    public boolean hasValue() {
+        return delegate.get().hasValue();
+    }
+
+    @Override
+    public <T> ConfigValue<T> as(Class<T> type) {
+        return delegate.get().as(type);
+    }
+
+    @Override
+    public <T> ConfigValue<T> map(Function<Config, T> mapper) {
+        return delegate.get().map(mapper);
+    }
+
+    @Override
+    public <T> ConfigValue<List<T>> asList(Class<T> type) throws ConfigException {
+        return delegate.get().asList(type);
+    }
+
+    @Override
+    public <T> ConfigValue<List<T>> mapList(Function<Config, T> mapper) throws ConfigException {
+        return delegate.get().mapList(mapper);
+    }
+
+    @Override
+    public <C extends Config> ConfigValue<List<C>> asNodeList() throws ConfigException {
+        return delegate.get().asNodeList();
+    }
+
+    @Override
+    public ConfigValue<Map<String, String>> asMap() throws ConfigException {
+        return delegate.get().asMap();
+    }
+
+    @Override
+    public ConfigValue<? extends Config> asNode() {
+        return delegate.get().asNode();
+    }
+
+    @Override
+    public ConfigValue<String> asString() {
+        return delegate.get().asString();
+    }
+
+    @Override
+    public ConfigValue<Boolean> asBoolean() {
+        return delegate.get().asBoolean();
+    }
+
+    @Override
+    public ConfigValue<Integer> asInt() {
+        return delegate.get().asInt();
+    }
+
+    @Override
+    public ConfigValue<Long> asLong() {
+        return delegate.get().asLong();
+    }
+
+    @Override
+    public ConfigValue<Double> asDouble() {
+        return delegate.get().asDouble();
+    }
+}

common/config/src/main/java/io/helidon/common/config/ConfigFactory.java

@@ -18,21 +18,44 @@
 
 import java.util.function.Supplier;
 
+import io.helidon.common.LazyValue;
 import io.helidon.common.Weight;
 import io.helidon.common.Weighted;
 import io.helidon.service.registry.Service;
+import io.helidon.service.registry.Services;
 
 /**
- * Default factory for configuration, that returns the current global config, or creates a new config instance.
- * This is to ensure we have a config instance in service registry even when there is no config implementation on classpath.
+ * Default {@link Config} factory.
+ * This factory exists as a fallback if there is no config implementation on classpath.
+ * <br>
+ * The created config instance is a delegate that honors the current "global" config.
  */
-@SuppressWarnings("removal")
-@Weight(Weighted.DEFAULT_WEIGHT - 20)
 @Service.Singleton
+@Weight(Weighted.DEFAULT_WEIGHT - 20)
+@SuppressWarnings({"removal", "ClassCanBeRecord"})
 class ConfigFactory implements Supplier<Config> {
+
+    private final LazyValue<Config> defaultConfig;
+    private final ConfigRef ref;
+
+    @Service.Inject
+    ConfigFactory(io.helidon.common.config.spi.ConfigProvider provider, ConfigRef ref) {
+        this.defaultConfig = LazyValue.create(provider::create);
+        this.ref = ref;
+    }
+
     @Override
     public Config get() {
-        // once GlobalConfig gets removed, we just return Config.create()
-        return GlobalConfig.configured() ? GlobalConfig.config() : Config.create();
+        return new ConfigDelegate(this::delegate);
+    }
+
+    private Config delegate() {
+        return ref.isSet() ? ref.get() : defaultConfig.get();
+    }
+
+    static Config createDefault() {
+        return Services.first(io.helidon.common.config.spi.ConfigProvider.class)
+                .map(io.helidon.common.config.spi.ConfigProvider::create)
+                .orElse(Config.empty());
     }
 }