refactor: use context instead of inject for our context stuff

extensions/rimor-params/src/main/java/st/networkers/rimor/params/ParamsExtension.java

@@ -11,9 +11,9 @@ public class ParamsExtension implements RimorExtension {
 
     @Override
     public void configure(Rimor rimor) {
-        rimor.registerProvider(new BooleanInstructionParamParser())
-                .registerProvider(new DefaultInstructionParamParser())
-                .registerProvider(new EnumInstructionParamParser())
-                .registerProvider(new StringInstructionParamParser());
+        rimor.registerExecutionContextProvider(new BooleanInstructionParamParser())
+                .registerExecutionContextProvider(new DefaultInstructionParamParser())
+                .registerExecutionContextProvider(new EnumInstructionParamParser())
+                .registerExecutionContextProvider(new StringInstructionParamParser());
     }
 }

extensions/rimor-params/src/main/java/st/networkers/rimor/params/parse/AbstractInstructionParamParser.java

@@ -1,12 +1,12 @@
 package st.networkers.rimor.params.parse;
 
-import st.networkers.rimor.inject.ExecutionContext;
-import st.networkers.rimor.inject.Token;
-import st.networkers.rimor.inject.ParameterToken;
+import st.networkers.rimor.context.ExecutionContext;
+import st.networkers.rimor.context.Token;
+import st.networkers.rimor.context.ParameterToken;
 import st.networkers.rimor.params.InstructionParam;
 import st.networkers.rimor.params.InstructionParams;
 import st.networkers.rimor.params.parse.support.StringInstructionParamParser;
-import st.networkers.rimor.inject.provide.AbstractRimorProvider;
+import st.networkers.rimor.context.provide.AbstractExecutionContextProvider;
 import st.networkers.rimor.reflect.CachedMethod;
 import st.networkers.rimor.reflect.CachedParameter;
 
@@ -19,7 +19,7 @@
  * <p>
  * Check {@link StringInstructionParamParser} for a quick example.
  */
-public abstract class AbstractInstructionParamParser<T> extends AbstractRimorProvider<T> implements InstructionParamParser<T> {
+public abstract class AbstractInstructionParamParser<T> extends AbstractExecutionContextProvider<T> implements InstructionParamParser<T> {
 
     protected static final Token<List<Object>> PARAMS_TOKEN = new Token<List<Object>>() {}.annotatedWith(InstructionParams.class);
 

extensions/rimor-params/src/main/java/st/networkers/rimor/params/parse/InstructionParamParser.java

@@ -1,13 +1,13 @@
 package st.networkers.rimor.params.parse;
 
-import st.networkers.rimor.inject.ExecutionContext;
-import st.networkers.rimor.inject.Token;
+import st.networkers.rimor.context.ExecutionContext;
+import st.networkers.rimor.context.Token;
 import st.networkers.rimor.params.InstructionParams;
 import st.networkers.rimor.params.parse.support.BooleanInstructionParamParser;
 import st.networkers.rimor.params.parse.support.DefaultInstructionParamParser;
 import st.networkers.rimor.params.parse.support.EnumInstructionParamParser;
 import st.networkers.rimor.params.parse.support.StringInstructionParamParser;
-import st.networkers.rimor.inject.provide.RimorProvider;
+import st.networkers.rimor.context.provide.ExecutionContextProvider;
 
 /**
  * Abstract class for providers that just parse an element from the {@link InstructionParams}-annotated lists.
@@ -18,7 +18,7 @@
  * @see EnumInstructionParamParser
  * @see StringInstructionParamParser
  */
-public interface InstructionParamParser<T> extends RimorProvider<T> {
+public interface InstructionParamParser<T> extends ExecutionContextProvider<T> {
 
     T parse(Object parameter, Token<T> token, ExecutionContext context);
 

extensions/rimor-params/src/main/java/st/networkers/rimor/params/parse/support/BooleanInstructionParamParser.java

@@ -1,8 +1,8 @@
 package st.networkers.rimor.params.parse.support;
 
 import org.apache.commons.lang3.ArrayUtils;
-import st.networkers.rimor.inject.ExecutionContext;
-import st.networkers.rimor.inject.Token;
+import st.networkers.rimor.context.ExecutionContext;
+import st.networkers.rimor.context.Token;
 import st.networkers.rimor.params.parse.AbstractInstructionParamParser;
 
 import java.util.Arrays;

extensions/rimor-params/src/main/java/st/networkers/rimor/params/parse/support/DefaultInstructionParamParser.java

@@ -1,7 +1,7 @@
 package st.networkers.rimor.params.parse.support;
 
-import st.networkers.rimor.inject.ExecutionContext;
-import st.networkers.rimor.inject.Token;
+import st.networkers.rimor.context.ExecutionContext;
+import st.networkers.rimor.context.Token;
 import st.networkers.rimor.params.parse.AbstractInstructionParamParser;
 
 /**

extensions/rimor-params/src/main/java/st/networkers/rimor/params/parse/support/EnumInstructionParamParser.java

@@ -1,7 +1,7 @@
 package st.networkers.rimor.params.parse.support;
 
-import st.networkers.rimor.inject.ExecutionContext;
-import st.networkers.rimor.inject.Token;
+import st.networkers.rimor.context.ExecutionContext;
+import st.networkers.rimor.context.Token;
 import st.networkers.rimor.params.parse.AbstractInstructionParamParser;
 
 /**

extensions/rimor-params/src/main/java/st/networkers/rimor/params/parse/support/StringInstructionParamParser.java

@@ -1,7 +1,7 @@
 package st.networkers.rimor.params.parse.support;
 
-import st.networkers.rimor.inject.ExecutionContext;
-import st.networkers.rimor.inject.Token;
+import st.networkers.rimor.context.ExecutionContext;
+import st.networkers.rimor.context.Token;
 import st.networkers.rimor.params.parse.AbstractInstructionParamParser;
 
 public class StringInstructionParamParser extends AbstractInstructionParamParser<String> {

extensions/rimor-params/src/test/java/st/networkers/rimor/params/parse/AbstractInstructionParamParserTest.java

@@ -5,9 +5,9 @@
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
-import st.networkers.rimor.inject.ExecutionContext;
-import st.networkers.rimor.inject.Token;
-import st.networkers.rimor.inject.ParameterToken;
+import st.networkers.rimor.context.ExecutionContext;
+import st.networkers.rimor.context.Token;
+import st.networkers.rimor.context.ParameterToken;
 import st.networkers.rimor.params.InstructionParam;
 import st.networkers.rimor.params.InstructionParamImpl;
 import st.networkers.rimor.params.InstructionParams;

extensions/rimor-params/src/test/java/st/networkers/rimor/params/parse/support/BooleanInstructionParamParserTest.java

@@ -2,7 +2,7 @@
 
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import st.networkers.rimor.inject.Token;
+import st.networkers.rimor.context.Token;
 import st.networkers.rimor.params.InstructionParam;
 
 import static org.assertj.core.api.Assertions.assertThat;

extensions/rimor-params/src/test/java/st/networkers/rimor/params/parse/support/EnumInstructionParamParserTest.java

@@ -1,7 +1,7 @@
 package st.networkers.rimor.params.parse.support;
 
 import org.junit.jupiter.api.Test;
-import st.networkers.rimor.inject.Token;
+import st.networkers.rimor.context.Token;
 import st.networkers.rimor.params.InstructionParam;
 
 import static org.assertj.core.api.Assertions.assertThat;

rimor/src/main/java/st/networkers/rimor/Rimor.java

@@ -6,58 +6,63 @@
 import st.networkers.rimor.extension.ExtensionManager;
 import st.networkers.rimor.extension.RimorExtension;
 import st.networkers.rimor.extension.SupportExtension;
-import st.networkers.rimor.inject.RimorInjector;
-import st.networkers.rimor.inject.provide.ProviderRegistry;
-import st.networkers.rimor.inject.provide.RimorProvider;
+import st.networkers.rimor.context.ExecutionContextService;
+import st.networkers.rimor.context.provide.ExecutionContextProviderRegistry;
+import st.networkers.rimor.context.provide.ExecutionContextProvider;
 import st.networkers.rimor.resolve.PathResolver;
 
 public class Rimor {
 
     private final BeanManager beanManager;
     private final CommandRegistry commandRegistry;
     private final CommandExecutor commandExecutor;
+    private final ExecutionContextProviderRegistry executionContextProviderRegistry;
+    private final ExecutionContextService executionContextService;
     private final ExtensionManager extensionManager;
-    private final ProviderRegistry providerRegistry;
     private final PathResolver pathResolver;
-    private final RimorInjector injector;
 
     public Rimor(BeanManager beanManager, CommandRegistry commandRegistry, CommandExecutor commandExecutor,
-                 ExtensionManager extensionManager, ProviderRegistry providerRegistry, PathResolver pathResolver,
-                 RimorInjector injector) {
+                 ExtensionManager extensionManager, ExecutionContextProviderRegistry executionContextProviderRegistry, PathResolver pathResolver,
+                 ExecutionContextService executionContextService) {
         this.beanManager = beanManager;
         this.commandRegistry = commandRegistry;
         this.commandExecutor = commandExecutor;
         this.extensionManager = extensionManager;
-        this.providerRegistry = providerRegistry;
+        this.executionContextProviderRegistry = executionContextProviderRegistry;
         this.pathResolver = pathResolver;
-        this.injector = injector;
+        this.executionContextService = executionContextService;
 
         this.registerExtension(new SupportExtension());
     }
 
+    /**
+     * Registers the given bean.
+     *
+     * @param bean the bean register
+     */
     public Rimor register(Object bean) {
         this.beanManager.processBean(bean);
         return this;
     }
 
     /**
-     * Registers the given {@link RimorProvider}.
+     * Registers the given {@link ExecutionContextProvider}.
      *
      * @param provider the provider to register
      */
-    public Rimor registerProvider(RimorProvider<?> provider) {
-        this.providerRegistry.register(provider);
+    public Rimor registerExecutionContextProvider(ExecutionContextProvider<?> provider) {
+        this.executionContextProviderRegistry.register(provider);
         return this;
     }
 
     /**
-     * Registers the given {@link RimorProvider}s.
+     * Registers the given {@link ExecutionContextProvider}s.
      *
      * @param providers the providers to register
      */
-    public Rimor registerProviders(RimorProvider<?>... providers) {
-        for (RimorProvider<?> provider : providers)
-            this.registerProvider(provider);
+    public Rimor registerExecutionContextProviders(ExecutionContextProvider<?>... providers) {
+        for (ExecutionContextProvider<?> provider : providers)
+            this.registerExecutionContextProvider(provider);
         return this;
     }
 
@@ -98,15 +103,15 @@ public ExtensionManager getExtensionManager() {
         return extensionManager;
     }
 
-    public ProviderRegistry getProviderRegistry() {
-        return providerRegistry;
+    public ExecutionContextProviderRegistry getProviderRegistry() {
+        return executionContextProviderRegistry;
     }
 
     public PathResolver getPathResolver() {
         return pathResolver;
     }
 
-    public RimorInjector getInjector() {
-        return injector;
+    public ExecutionContextService getExecutionContextService() {
+        return executionContextService;
     }
 }

rimor/src/main/java/st/networkers/rimor/bean/BeanManager.java

@@ -1,17 +1,27 @@
 package st.networkers.rimor.bean;
 
+import st.networkers.rimor.context.provide.ExecutionContextProviderRegistry;
+
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
 
 public class BeanManager {
 
     private final Collection<BeanProcessor> beanProcessors = new ArrayList<>();
 
+    private final Map<Object, ExecutionContextProviderRegistry> providerRegistries = new HashMap<>();
+
     public void registerBeanProcessor(BeanProcessor beanProcessor) {
         this.beanProcessors.add(beanProcessor);
     }
 
     public void processBean(Object bean) {
         this.beanProcessors.forEach(beanProcessor -> beanProcessor.process(bean));
     }
+
+    public ExecutionContextProviderRegistry getProviderRegistry(Object bean) {
+        return this.providerRegistries.get(bean);
+    }
 }

rimor/src/main/java/st/networkers/rimor/inject/ExecutionContext.java → rimor/src/main/java/st/networkers/rimor/context/ExecutionContext.java

@@ -1,4 +1,4 @@
-package st.networkers.rimor.inject;
+package st.networkers.rimor.context;
 
 import st.networkers.rimor.util.MatchingMap;
 

rimor/src/main/java/st/networkers/rimor/context/ExecutionContextService.java

@@ -0,0 +1,47 @@
+package st.networkers.rimor.context;
+
+import st.networkers.rimor.context.provide.ExecutionContextProvider;
+import st.networkers.rimor.reflect.CachedMethod;
+
+import java.util.Optional;
+
+/**
+ * Provides an instance bound to a given {@link Token} from an {@link ExecutionContext} or a registered provider.
+ */
+public interface ExecutionContextService {
+
+    /**
+     * Gets an {@link Optional} wrapping the object bound to the given {@link Token} from the given
+     * {@link ExecutionContext}, if able. Otherwise, gets it from a registered {@link ExecutionContextProvider}, or
+     * returns an empty {@code Optional} if there are no available {@code ExecutionContextProvider} for the
+     * given {@code Token}.
+     *
+     * @param token   the token to get its bound object
+     * @param context the context of a command execution
+     * @return an {@link Optional} wrapping the object bound to the token, or empty
+     */
+    <T> Optional<T> get(Token<T> token, ExecutionContext context);
+
+    /**
+     * Gets an {@link Optional} wrapping the object bound to the given {@link Token} from the given
+     * {@link ExecutionContext}, if able. Otherwise, gets it from a registered {@link ExecutionContextProvider}, or
+     * returns an empty {@code Optional} if there are no available {@code ExecutionContextProvider} for the
+     * given {@code Token}.
+     *
+     * @param token   the token to get its bound object
+     * @param context the context of a command execution
+     * @param bean    the bean to use its local providers
+     * @return an {@link Optional} wrapping the object bound to the token, or empty
+     */
+    <T> Optional<T> get(Token<T> token, ExecutionContext context, Object bean);
+
+    /**
+     * Invokes the given method injecting all its parameters following {@link #get(Token, ExecutionContext)}
+     *
+     * @param cachedMethod the method to invoke
+     * @param instance     an instance of the method's class to invoke it on, or {@code null} if static
+     * @param context      the context of a command execution
+     * @return the result of executing the method
+     */
+    Object invokeMethod(CachedMethod cachedMethod, Object instance, ExecutionContext context);
+}

rimor/src/main/java/st/networkers/rimor/context/ExecutionContextServiceImpl.java

@@ -0,0 +1,58 @@
+package st.networkers.rimor.context;
+
+import st.networkers.rimor.bean.BeanManager;
+import st.networkers.rimor.context.provide.ExecutionContextProviderRegistry;
+import st.networkers.rimor.reflect.CachedMethod;
+import st.networkers.rimor.reflect.CachedParameter;
+import st.networkers.rimor.util.OptionalUtils;
+import st.networkers.rimor.util.ReflectionUtils;
+
+import java.util.Optional;
+
+public class ExecutionContextServiceImpl implements ExecutionContextService {
+
+    private final BeanManager beanManager;
+    private final ExecutionContextProviderRegistry globalExecutionContextProviderRegistry;
+
+    public ExecutionContextServiceImpl(BeanManager beanManager, ExecutionContextProviderRegistry globalExecutionContextProviderRegistry) {
+        this.beanManager = beanManager;
+        this.globalExecutionContextProviderRegistry = globalExecutionContextProviderRegistry;
+    }
+
+    @Override
+    public <T> Optional<T> get(Token<T> token, ExecutionContext context) {
+        return OptionalUtils.firstPresent(
+                context.get(token),
+                () -> this.fromProviderRegistry(globalExecutionContextProviderRegistry, token, context)
+        );
+    }
+
+    @Override
+    public <T> Optional<T> get(Token<T> token, ExecutionContext context, Object bean) {
+        return OptionalUtils.firstPresent(
+                context.get(token),
+                () -> this.fromProviderRegistry(beanManager.getProviderRegistry(bean), token, context),
+                () -> this.fromProviderRegistry(globalExecutionContextProviderRegistry, token, context)
+        );
+    }
+
+    private <T> Optional<T> fromProviderRegistry(ExecutionContextProviderRegistry executionContextProviderRegistry, Token<T> token, ExecutionContext context) {
+        return executionContextProviderRegistry.findFor(token).map(provider -> provider.get(token, context));
+    }
+
+    @Override
+    public Object invokeMethod(CachedMethod method, Object instance, ExecutionContext context) {
+        return ReflectionUtils.invoke(method.getMethod(), instance, resolveParameters(method, context));
+    }
+
+    private Object[] resolveParameters(CachedMethod method, ExecutionContext context) {
+        Object[] parameters = new Object[method.getParameters().size()];
+
+        int i = 0;
+        for (CachedParameter parameter : method.getParameters()) {
+            parameters[i++] = this.get(ParameterToken.build(method, parameter), context).orElse(null);
+        }
+
+        return parameters;
+    }
+}

rimor/src/main/java/st/networkers/rimor/inject/ParameterToken.java → rimor/src/main/java/st/networkers/rimor/context/ParameterToken.java

@@ -1,4 +1,4 @@
-package st.networkers.rimor.inject;
+package st.networkers.rimor.context;
 
 import st.networkers.rimor.reflect.CachedMethod;
 import st.networkers.rimor.reflect.CachedParameter;

rimor/src/main/java/st/networkers/rimor/inject/Token.java → rimor/src/main/java/st/networkers/rimor/context/Token.java

@@ -1,4 +1,4 @@
-package st.networkers.rimor.inject;
+package st.networkers.rimor.context;
 
 import org.apache.commons.lang3.ClassUtils;
 import org.apache.commons.lang3.reflect.TypeUtils;