Remove some classes, use new ones, add di

Author: AnotherRegularDude

Gemfile.lock

@@ -2,6 +2,7 @@ PATH
   remote: .
   specs:
     resol (1.0.0)
+      dry-container
 
 GEM
   remote: https://rubygems.org/
@@ -36,6 +37,8 @@ GEM
     diff-lcs (1.5.1)
     docile (1.4.1)
     drb (2.2.1)
+    dry-container (0.11.0)
+      concurrent-ruby (~> 1.0)
     dry-inflector (1.1.0)
     dry-initializer (3.1.1)
     i18n (1.14.6)

lib/resol.rb

@@ -1,20 +1,20 @@
 # frozen_string_literal: true
 
+require "dry-container"
+
 require_relative "resol/version"
 require_relative "resol/configuration"
-require_relative "resol/initializers"
+
+require_relative "resol/injector"
 require_relative "resol/service"
 require_relative "resol/plugins"
+require_relative "resol/dependency_container"
 
 module Resol
   extend self
 
   def config
-    Configuration
-  end
-
-  def configure
-    yield config
+    @config ||= Configuration.new
   end
 
   # rubocop:disable Naming/MethodName

lib/resol/configuration.rb

@@ -1,19 +1,19 @@
 # frozen_string_literal: true
 
 module Resol
-  module Configuration
-    extend self
+  class Configuration
+    DEFAULT_CONFIG_VALUES = { classes_allowed_to_patch: ["Resol::Service"] }.freeze
 
-    def smart_config
-      return nil if smart_not_loaded?
+    def initialize
+      self.data = DEFAULT_CONFIG_VALUES.deep_dup
+    end
 
-      SmartCore::Initializer::Configuration.config
+    DEFAULT_CONFIG_VALUES.each_key do |setting_name|
+      define_method(setting_name) { data.fetch(setting_name) }
     end
 
     private
 
-    def smart_not_loaded?
-      !defined?(SmartCore::Initializer::Configuration)
-    end
+    attr_accessor :data
   end
 end

lib/resol/dependency_handler.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Resol
+  class DependencyHandler
+    extend Dry::Container::Mixin
+
+    namespace(:external_libs) do
+      register(:smartcore_injector, memoize: true) do
+        require "smart_core/initializer"
+
+        installer_proc = proc { include SmartCore::Initializer }
+        Resol::Injector.new(installer_proc)
+      end
+
+      register(:dry_injector, memoize: true) do
+        require "dry/initializer"
+
+        installer_proc = proc { extend Dry::Initializer }
+        Resol::Injector.new(installer_proc)
+      end
+    end
+
+    namespace(:lib) do
+      register(:plugin_manager) { Plugins::Manager.new }
+    end
+  end
+end

lib/resol/initializers.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Resol
+  class Injector
+    InjectMarker = Module.new
+
+    def initialize(proc_register)
+      self.proc_register = proc_register
+    end
+
+    def inject!(service_class)
+      error!("parent or this class already injected") if service_class.is_a?(InjectMarker)
+
+      service_class.instance_eval(&proc_register)
+      service_class.include(InjectMarker)
+    end
+
+    private
+
+    attr_accessor :proc_register
+
+    def error!(msg)
+       raise msg
+    end
+  end
+end

lib/resol/injector.rb

@@ -6,30 +6,36 @@ module Resol
   module Plugins
     PLUGINS_PATH = Pathname("resol/plugins")
     class Manager
-      def initialize(target_class = nil)
+      def initialize
+        self.allowed_classes = resolve_allowed_classes
         self.plugins = []
-        self.target_class = target_class || Resol::Service
       end
 
-      def plugin(plugin_name)
+      def plugin(caller_class, plugin_name)
         plugin_name = plugin_name.to_s
+
+        return if allowed_classes.exclude?(caller_class)
         return if plugins.include?(plugin_name)
 
         plugin_module = find_plugin_module(plugin_name)
         if defined?(plugin_module::InstanceMethods)
-          target_class.prepend(plugin_module::InstanceMethods)
+          caller_class.prepend(plugin_module::InstanceMethods)
         end
 
         if defined?(plugin_module::ClassMethods)
-          target_class.singleton_class.prepend(plugin_module::ClassMethods)
+          caller_class.singleton_class.prepend(plugin_module::ClassMethods)
         end
 
         plugins << plugin_name
       end
 
       private
 
-      attr_accessor :plugins, :target_class
+      attr_accessor :plugins
+
+      def resolve_allowed_classes
+        Resol.config.classes_allowed_to_patch.map { |name| Object.const_get(name) }
+      end
 
       def find_plugin_module(plugin_name)
         require PLUGINS_PATH.join(plugin_name)

lib/resol/plugins.rb

@@ -9,12 +9,6 @@ module ClassMethods
         def handle_catch(_service)
           yield
         end
-
-        def call_service(service)
-          service.call.tap do |res|
-            return Resol::Service::NOT_EXITED unless res.is_a?(Service::Result)
-          end
-        end
       end
 
       module InstanceMethods

lib/resol/plugins/return_in_service.rb

@@ -30,9 +30,6 @@ def message
     include Resol::Builder
     include Resol::Callbacks
 
-    NOT_EXITED = Object.new.freeze
-    BASE_CLASS = self
-
     Result = Struct.new(:data)
 
     class << self
@@ -41,16 +38,13 @@ def inherited(klass)
         super
       end
 
-      def use_initializer!(initializer_lib)
-        Initializers.apply!(self, initializer_lib)
+      def inject_initializer!(injector_name)
+        injector = DependencyContainer.resolve("libs.#{injector_name}")
+        injector.inject!(self)
       end
 
       def plugin(...)
-        if self::BASE_CLASS != self
-          raise ArgumentError, "can load plugins only on base Resol::Service"
-        end
-
-        manager.plugin(...)
+        manager.plugin(self, ...)
       end
 
       def call(...)
@@ -59,15 +53,12 @@ def call(...)
         result = handle_catch(service) do
           service.instance_variable_set(:@__performing__, true)
           __run_callbacks__(service)
-          call_service(service)
+          service.call
         end
+        return Resol::Success(result.data) if service.__result_method__called__
 
-        if result == NOT_EXITED
-          error_message = "No `#success!` or `#fail!` called in `#call` method in #{service.class}."
-          raise InvalidCommandImplementation, error_message
-        else
-          Resol::Success(result.data)
-        end
+        error_message = "No `#success!` or `#fail!` called in `#call` method in #{service.class}."
+        raise InvalidCommandImplementation, error_message
       rescue self::Failure => e
         Resol::Failure(e)
       end
@@ -79,50 +70,45 @@ def call!(...)
       private
 
       def manager
-        @manager ||= Plugins::Manager.new
-      end
-
-      def handle_catch(service)
-        catch(service) do
-          yield
-          NOT_EXITED
-        end
+        @manager ||= DependencyContainer.resolve(:base_plugin_manager)
       end
 
-      def call_service(service)
-        service.call
-        NOT_EXITED
+      def handle_catch(service, &)
+        catch(service, &)
       end
     end
 
     # @!method call
 
+    attr_accessor :__result_method__called__
+
     private
 
     attr_reader :__performing__
 
     def fail!(code, data = nil)
-      check_performing do
-        raise self.class::Failure.new(code, data)
-      end
+      check_performing!
+      raise self.class::Failure.new(code, data)
     end
 
     def success!(data = nil)
-      check_performing do
-        proceed_return(self, Result.new(data))
-      end
+      check_performing!
+      result_method_called!
+      proceed_return(self, Result.new(data))
     end
 
-    def check_performing
-      if __performing__
-        yield
-      else
-        error_message =
-          "It looks like #call instance method was called directly in #{self.class}. " \
-          "You must always use class-level `.call` or `.call!` method."
+    def check_performing!
+      return if __performing__
 
-        raise InvalidCommandCall, error_message
-      end
+      error_message =
+        "It looks like #call instance method was called directly in #{self.class}. " \
+        "You must always use class-level `.call` or `.call!` method."
+
+      raise InvalidCommandCall, error_message
+    end
+
+    def result_method_called!
+      self.__result_method__called__ = true
     end
 
     def proceed_return(service, data)

lib/resol/service.rb

@@ -16,4 +16,6 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = Gem::Requirement.new(">= 3.1.0")
   spec.files = `git ls-files -z`.split("\x0").reject { |f| f.include?("spec") }
   spec.require_paths = ["lib"]
+
+  spec.add_dependency "dry-container"
 end