And added even more Javadoc

Author: maksymuimanov

spring-boot-python-executor-autoconfigure/src/main/java/io/w4t3rcs/python/condition/AbstractResolverCondition.java

@@ -1,5 +1,6 @@
 package io.w4t3rcs.python.condition;
 
+import io.w4t3rcs.python.config.PythonResolverConfiguration;
 import io.w4t3rcs.python.properties.PythonResolverProperties;
 import org.springframework.context.annotation.Condition;
 import org.springframework.context.annotation.ConditionContext;
@@ -9,20 +10,70 @@
 import java.util.Arrays;
 import java.util.Objects;
 
+/**
+ * Base {@link Condition} implementation that checks for the presence of a specific
+ * declared Python resolver in the Spring environment configuration.
+ * <p>
+ * This condition verifies whether the {@code spring.python.resolver.declared} property
+ * contains a given resolver identifier (case-insensitive).
+ * </p>
+ * <p>
+ * Implementations must specify the resolver to check by overriding {@link #getDeclaredResolver()}.
+ * </p>
+ * <p>
+ * The property {@code spring.python.resolver.declared} is expected to be a list/array of strings.
+ * If the property is missing or empty, the condition will not match.
+ * </p>
+ *
+ * @see Condition
+ * @see PythonResolverProperties.DeclaredResolver
+ * @see PythonResolverConfiguration
+ * @author w4t3rcs
+ * @since 1.0.0
+ */
 public abstract class AbstractResolverCondition implements Condition {
     private static final String SPRING_PYTHON_RESOLVER_DECLARED_PROPERTY = "spring.python.resolver.declared";
 
+    /**
+     * Checks whether the Spring environment contains the configured declared resolver.
+     * Delegates the check to {@link #matchesByDeclaredResolver(ConditionContext, PythonResolverProperties.DeclaredResolver)}.
+     *
+     * @param context the condition context, must not be {@code null}
+     * @param metadata metadata of the annotated component, ignored in this implementation
+     * @return {@code true} if the declared resolver is present in the environment property, {@code false} otherwise
+     */
     @Override
     public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
         return this.matchesByDeclaredResolver(context, this.getDeclaredResolver());
     }
 
-    public boolean matchesByDeclaredResolver(ConditionContext context, PythonResolverProperties.DeclaredResolver propertyValue) {
+    /**
+     * Checks if the specified declared resolver is present in the
+     * {@code spring.python.resolver.declared} property of the environment.
+     * <p>
+     * The property is read as a string array and matched case-insensitively against
+     * the string representation of the {@code propertyValue} argument.
+     * </p>
+     * <p>
+     * If the property is missing or empty, this method returns {@code false}.
+     * </p>
+     *
+     * @param context the condition context providing access to environment, must not be {@code null}
+     * @param propertyValue the declared resolver to check for, must not be {@code null}
+     * @return {@code true} if the declared resolver is found in the property, {@code false} otherwise
+     */
+    protected boolean matchesByDeclaredResolver(ConditionContext context, PythonResolverProperties.DeclaredResolver propertyValue) {
         Environment environment = context.getEnvironment();
         String[] property = environment.getProperty(SPRING_PYTHON_RESOLVER_DECLARED_PROPERTY, String[].class);
         return Arrays.stream(Objects.requireNonNull(property))
                 .anyMatch(declared -> declared.equals(propertyValue.toString().toLowerCase()));
     }
 
+    /**
+     * Returns the {@link PythonResolverProperties.DeclaredResolver} value
+     * that this condition should match against.
+     *
+     * @return the declared resolver to check, never {@code null}
+     */
     protected abstract PythonResolverProperties.DeclaredResolver getDeclaredResolver();
 }

spring-boot-python-executor-autoconfigure/src/main/java/io/w4t3rcs/python/condition/PrintedResultResolverCondition.java

@@ -1,9 +1,25 @@
 package io.w4t3rcs.python.condition;
 
+import io.w4t3rcs.python.config.PythonResolverConfiguration;
 import io.w4t3rcs.python.properties.PythonResolverProperties;
 import lombok.AccessLevel;
 import lombok.Getter;
 
+/**
+ * {@link AbstractResolverCondition} implementation that checks whether the
+ * {@link PythonResolverProperties.DeclaredResolver#PRINTED_RESULT} resolver
+ * is declared in the Spring environment property {@code spring.python.resolver.declared}.
+ * <p>
+ * This condition is used to enable components related to printed result processing
+ * only when the {@code PRINTED_RESULT} resolver is explicitly declared.
+ * </p>
+ *
+ * @see AbstractResolverCondition
+ * @see PythonResolverProperties.DeclaredResolver#PRINTED_RESULT
+ * @see PythonResolverConfiguration
+ * @author w4t3rcs
+ * @since 1.0.0
+ */
 @Getter(AccessLevel.PROTECTED)
 public class PrintedResultResolverCondition extends AbstractResolverCondition {
     private final PythonResolverProperties.DeclaredResolver declaredResolver = PythonResolverProperties.DeclaredResolver.PRINTED_RESULT;

spring-boot-python-executor-autoconfigure/src/main/java/io/w4t3rcs/python/condition/Py4JResolverCondition.java

@@ -1,9 +1,25 @@
 package io.w4t3rcs.python.condition;
 
+import io.w4t3rcs.python.config.PythonResolverConfiguration;
 import io.w4t3rcs.python.properties.PythonResolverProperties;
 import lombok.AccessLevel;
 import lombok.Getter;
 
+/**
+ * {@link AbstractResolverCondition} implementation that verifies whether the
+ * {@link PythonResolverProperties.DeclaredResolver#PY4J} resolver
+ * is declared in the Spring environment property {@code spring.python.resolver.declared}.
+ * <p>
+ * This condition controls activation of components related to Py4J integration,
+ * ensuring they are enabled only when the {@code PY4J} resolver is explicitly declared.
+ * </p>
+ *
+ * @see AbstractResolverCondition
+ * @see PythonResolverProperties.DeclaredResolver#PY4J
+ * @see PythonResolverConfiguration
+ * @author w4t3rcs
+ * @since 1.0.0
+ */
 @Getter(AccessLevel.PROTECTED)
 public class Py4JResolverCondition extends AbstractResolverCondition {
     private final PythonResolverProperties.DeclaredResolver declaredResolver = PythonResolverProperties.DeclaredResolver.PY4J;

spring-boot-python-executor-autoconfigure/src/main/java/io/w4t3rcs/python/condition/RestrictedPythonResolverCondition.java

@@ -1,9 +1,25 @@
 package io.w4t3rcs.python.condition;
 
+import io.w4t3rcs.python.config.PythonResolverConfiguration;
 import io.w4t3rcs.python.properties.PythonResolverProperties;
 import lombok.AccessLevel;
 import lombok.Getter;
 
+/**
+ * {@link AbstractResolverCondition} implementation that checks whether the
+ * {@link PythonResolverProperties.DeclaredResolver#RESTRICTED_PYTHON} resolver
+ * is declared in the Spring environment property {@code spring.python.resolver.declared}.
+ * <p>
+ * This condition activates components related to RestrictedPython execution
+ * only if the {@code RESTRICTED_PYTHON} resolver is explicitly declared.
+ * </p>
+ *
+ * @see AbstractResolverCondition
+ * @see PythonResolverProperties.DeclaredResolver#RESTRICTED_PYTHON
+ * @see PythonResolverConfiguration
+ * @author w4t3rcs
+ * @since 1.0.0
+ */
 @Getter(AccessLevel.PROTECTED)
 public class RestrictedPythonResolverCondition extends AbstractResolverCondition {
     private final PythonResolverProperties.DeclaredResolver declaredResolver = PythonResolverProperties.DeclaredResolver.RESTRICTED_PYTHON;

spring-boot-python-executor-autoconfigure/src/main/java/io/w4t3rcs/python/condition/ResultResolverCondition.java

@@ -1,9 +1,25 @@
 package io.w4t3rcs.python.condition;
 
+import io.w4t3rcs.python.config.PythonResolverConfiguration;
 import io.w4t3rcs.python.properties.PythonResolverProperties;
 import lombok.AccessLevel;
 import lombok.Getter;
 
+/**
+ * {@link AbstractResolverCondition} implementation that checks whether the
+ * {@link PythonResolverProperties.DeclaredResolver#RESULT} resolver
+ * is declared in the Spring environment property {@code spring.python.resolver.declared}.
+ * <p>
+ * This condition activates components related to result processing
+ * only if the {@code RESULT} resolver is explicitly declared.
+ * </p>
+ *
+ * @see AbstractResolverCondition
+ * @see PythonResolverProperties.DeclaredResolver#RESULT
+ * @see PythonResolverConfiguration
+ * @author w4t3rcs
+ * @since 1.0.0
+ */
 @Getter(AccessLevel.PROTECTED)
 public class ResultResolverCondition extends AbstractResolverCondition {
     private final PythonResolverProperties.DeclaredResolver declaredResolver = PythonResolverProperties.DeclaredResolver.RESULT;

spring-boot-python-executor-autoconfigure/src/main/java/io/w4t3rcs/python/condition/SpelythonResolverCondition.java

@@ -1,9 +1,25 @@
 package io.w4t3rcs.python.condition;
 
+import io.w4t3rcs.python.config.PythonResolverConfiguration;
 import io.w4t3rcs.python.properties.PythonResolverProperties;
 import lombok.AccessLevel;
 import lombok.Getter;
 
+/**
+ * {@link AbstractResolverCondition} implementation that checks whether the
+ * {@link PythonResolverProperties.DeclaredResolver#SPELYTHON} resolver
+ * is declared in the Spring environment property {@code spring.python.resolver.declared}.
+ * <p>
+ * This condition activates components related to SpEL expression resolution in Python scripts
+ * only if the {@code SPELYTHON} resolver is explicitly declared.
+ * </p>
+ *
+ * @see AbstractResolverCondition
+ * @see PythonResolverProperties.DeclaredResolver#SPELYTHON
+ * @see PythonResolverConfiguration
+ * @author w4t3rcs
+ * @since 1.0.0
+ */
 @Getter(AccessLevel.PROTECTED)
 public class SpelythonResolverCondition extends AbstractResolverCondition {
     private final PythonResolverProperties.DeclaredResolver declaredResolver = PythonResolverProperties.DeclaredResolver.SPELYTHON;

spring-boot-python-executor-autoconfigure/src/main/java/io/w4t3rcs/python/config/PythonResolverConfiguration.java

@@ -14,27 +14,109 @@
 import org.springframework.core.annotation.Order;
 
 import java.util.List;
-
 /**
- * Main configuration class for {@link PythonResolver}.
- * This class sets up the core infrastructure for {@link PythonResolver} bean declaration.
+ * Main configuration class for {@link PythonResolver} beans.
+ * <p>
+ * This configuration class defines and registers various {@link PythonResolver} implementations
+ * as Spring beans, each conditionally created based on specific environment properties or
+ * declared resolver conditions.
+ * </p>
+ * <p>
+ * Each {@link PythonResolver} bean is assigned an order that determines the sequence of
+ * resolver application when used collectively.
+ * </p>
+ * <p>
+ * The configuration also provides a default {@link PythonResolverHolder} bean implementation
+ * {@link BasicPythonResolverHolder} if no other {@link PythonResolverHolder} bean is present
+ * in the Spring context.
+ * </p>
+ *
+ * <pre>{@code
+ * // Example of enabling the Spelython and Result resolvers via application.properties:
+ * spring.python.resolver.declared=spelython, result
+ *
+ * // Example of enabling the Py4J resolver:
+ * spring.python.resolver.declared=py4j
+ * spring.python.py4j.enabled=true
+ *
+ * // Example usage of injected PythonResolverHolder in a service:
+ * @Autowired
+ * private PythonResolverHolder resolverHolder;
+ *
+ * public String executeScript(String script) {
+ *     return resolverHolder.resolveAll(script, Map.of());
+ * }
+ * }</pre>
+ *
+ * @see PythonResolver
+ * @see SpelythonResolver
+ * @see Py4JResolver
+ * @see RestrictedPythonResolver
+ * @see ResultResolver
+ * @see PrintedResultResolver
+ * @see PythonResolverHolder
+ * @see BasicPythonResolverHolder
+ * @see SpelythonResolverCondition
+ * @see Py4JResolverCondition
+ * @see RestrictedPythonResolverCondition
+ * @see ResultResolverCondition
+ * @see PrintedResultResolverCondition
+ * @author w4t3rcs
+ * @since 1.0.0
  */
 @Configuration
 @EnableConfigurationProperties(PythonResolverProperties.class)
 public class PythonResolverConfiguration {
+    /**
+     * Order value for {@link SpelythonResolver} bean.
+     */
     public static final int SPELYTHON_RESOLVER_ORDER = 0;
+    /**
+     * Order value for {@link Py4JResolver} bean.
+     */
     public static final int PY4J_RESOLVER_ORDER = 50;
+    /**
+     * Order value for {@link RestrictedPythonResolver} bean.
+     */
     public static final int RESTRICTED_PYTHON_RESOLVER_ORDER = 100;
+    /**
+     * Order value for {@link ResultResolver} bean.
+     */
     public static final int RESULT_RESOLVER_ORDER = 150;
+    /**
+     * Order value for {@link PrintedResultResolver} bean.
+     */
     public static final int PRINTED_RESULT_RESOLVER_ORDER = 200;
 
+    /**
+     * Creates a {@link SpelythonResolver} bean.
+     * <p>
+     * This bean is created only if {@link SpelythonResolverCondition} matches,
+     * which requires {@code spring.python.resolver.declared} to contain "spelython".
+     * </p>
+     *
+     * @param resolverProperties {@link PythonResolverProperties} bean, must not be null
+     * @param applicationContext the Spring {@link ApplicationContext}, must not be null
+     * @param objectMapper Jackson {@link ObjectMapper} bean, must not be null
+     * @return configured {@link SpelythonResolver} instance, never null
+     */
     @Bean
     @Order(SPELYTHON_RESOLVER_ORDER)
     @Conditional(SpelythonResolverCondition.class)
     public PythonResolver spelythonResolver(PythonResolverProperties resolverProperties, ApplicationContext applicationContext, ObjectMapper objectMapper) {
         return new SpelythonResolver(resolverProperties, applicationContext, objectMapper);
     }
 
+    /**
+     * Creates a {@link Py4JResolver} bean.
+     * <p>
+     * This bean is created only if {@link Py4JResolverCondition} matches and
+     * the property {@code spring.python.py4j.enabled} is set to {@code true}.
+     * </p>
+     *
+     * @param resolverProperties {@link PythonResolverProperties} bean, must not be null
+     * @return configured {@link Py4JResolver} instance, never null
+     */
     @Bean
     @Order(PY4J_RESOLVER_ORDER)
     @Conditional(Py4JResolverCondition.class)
@@ -43,28 +125,66 @@ public PythonResolver py4JResolver(PythonResolverProperties resolverProperties)
         return new Py4JResolver(resolverProperties);
     }
 
+    /**
+     * Creates a {@link RestrictedPythonResolver} bean.
+     * <p>
+     * This bean is created only if {@link RestrictedPythonResolverCondition} matches,
+     * which requires {@code spring.python.resolver.declared} to contain "restricted_python".
+     * </p>
+     *
+     * @param resolverProperties {@link PythonResolverProperties} bean, must not be null
+     * @return configured {@link RestrictedPythonResolver} instance, never null
+     */
     @Bean
     @Order(RESTRICTED_PYTHON_RESOLVER_ORDER)
     @Conditional(RestrictedPythonResolverCondition.class)
     public PythonResolver restrictedPythonResolver(PythonResolverProperties resolverProperties) {
         return new RestrictedPythonResolver(resolverProperties);
     }
 
+    /**
+     * Creates a {@link ResultResolver} bean.
+     * <p>
+     * This bean is created only if {@link ResultResolverCondition} matches,
+     * which requires {@code spring.python.resolver.declared} to contain "result".
+     * </p>
+     *
+     * @param resolverProperties {@link PythonResolverProperties} bean, must not be null
+     * @return configured {@link ResultResolver} instance, never null
+     */
     @Bean
     @Order(RESULT_RESOLVER_ORDER)
     @Conditional(ResultResolverCondition.class)
     public PythonResolver resultResolver(PythonResolverProperties resolverProperties) {
         return new ResultResolver(resolverProperties);
     }
 
+    /**
+     * Creates a {@link PrintedResultResolver} bean.
+     * <p>
+     * This bean is created only if {@link ResultResolverCondition} matches,
+     * which requires {@code spring.python.resolver.declared} to contain "printed_result".
+     * </p>
+     *
+     * @param resolverProperties {@link PythonResolverProperties} bean, must not be null
+     * @return configured {@link PrintedResultResolver} instance, never null
+     */
     @Bean
     @Order(PRINTED_RESULT_RESOLVER_ORDER)
     @Conditional(PrintedResultResolverCondition.class)
-    @ConditionalOnProperty(name = "spring.python.executor.type", havingValue = "local")
     public PythonResolver printedResultResolver(PythonResolverProperties resolverProperties) {
         return new PrintedResultResolver(resolverProperties);
     }
 
+    /**
+     * Creates the default {@link PythonResolverHolder} bean if none is defined.
+     * <p>
+     * This holder aggregates all available {@link PythonResolver} beans in the context.
+     * </p>
+     *
+     * @param pythonResolvers list of all registered {@link PythonResolver} beans, never null but can be empty
+     * @return a {@link BasicPythonResolverHolder} instance containing the given resolvers, never null
+     */
     @Bean
     @ConditionalOnMissingBean(PythonResolverHolder.class)
     public PythonResolverHolder basicPythonResolverHolder(List<PythonResolver> pythonResolvers) {