aux 0.1.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 862a78e8879ec01edc04a4c59c1a7468366f6b9ca8c10791b974553090e4f6c3
-  data.tar.gz: f247febfd9e323d3ed778dcf20cd3b73504a33feecbbeae06129465426143fda
+  metadata.gz: a5a8f2a8523d27a026f50b5e10f3d87c0603a7e2a6710ec0f788b824075c98e0
+  data.tar.gz: 9e5873e8a90853626176568ddd63013a09e5dff9da442a54e6f5955344e2461f
 SHA512:
-  metadata.gz: 4fb78b1df17d234f1a1738143ca873f1c470f2aafc194dbcdeed2d730240ba3cfc07aeabf19fb33f0d7e9426fcb4523e53394d93e048cc836a856a2a750b2101
-  data.tar.gz: 100e911b442a7e422a5afd122f42e908ee39fe05a66f60db5ee8294ab4efb697a94234d5d8676f6e39d9ae8a849aa60c56112bdc7985700b5b50e42acc68a425
+  metadata.gz: a4a734ffb338fdb30efc987eaadc47378f733818681a126ceddd2d609116ced8cf23474607e8c5e633d65d7f71c232081c2da04b51ef2c840c242d6a1850b26e
+  data.tar.gz: 4a8982b1e6d9e1763676537c8ffb8c900f7209af29c096dab88acced564e5b1d25ef6f17644f2227e40fc872bea30a25f2db5a541a48c3e314db92444026bf68

data/MIT-LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2022 Evgeny Boyko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/aux.gemspec

@@ -4,17 +4,14 @@ Gem::Specification.new do |specification|
   specification.name = 'aux'
   specification.version = Aux::VERSION
   specification.summary = 'Supplementary tools for more effective development'
-  specification.files = Dir['LICENSE', 'README.md', 'aux.gemspec', 'lib/**/*']
+  specification.files = Dir['MIT-LICENSE', 'README.md', 'aux.gemspec', 'lib/**/*']
 
   specification.authors = ['Evgeny Boyko']
   specification.email = ['eboyko@eboyko.ru']
   specification.homepage = 'https://github.com/eboyko/aux'
 
+  specification.add_dependency 'concurrent-ruby', '~> 1.2', '>= 1.2.3'
   specification.add_dependency 'activemodel', '>= 6.1', '< 8'
-  specification.add_dependency 'dry-container', '>= 0.9.0', '<= 0.11'
-
-  specification.add_development_dependency 'zeitwerk', '~> 2.5'
-  specification.add_development_dependency 'rubocop', '~> 1.36.0'
 
   specification.required_ruby_version = '>= 2.7.1'
   specification.metadata['rubygems_mfa_required'] = 'true'

data/lib/aux/carriers/failure.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Aux
+  module Carriers
+    # Describes a service failure
+    class Failure
+      # @!attribute [r] code
+      #   @return [Symbol]
+      # @!attribute [r] details
+      #   @return [Object, nil]
+      # @!attribute [r] payload
+      #   @return [Object, nil]
+      attr_reader :code, :details, :payload
+
+      # @param code [Symbol]
+      # @param details [Object, nil]
+      # @param payload [Object, nil]
+      def initialize(code, details = nil, payload = nil)
+        @code = code
+        @details = details
+        @payload = payload
+      end
+
+      # @return [FalseClass]
+      def succeeded?
+        false
+      end
+
+      # @!method successful?
+      #   @return [FalseClass]
+      alias successful? succeeded?
+
+      # @!method success?
+      #   @return [FalseClass]
+      alias success? succeeded?
+
+      # @return [TrueClass]
+      def failed?
+        true
+      end
+
+      # @!method failure?
+      #   @return [TrueClass]
+      alias failure? failed?
+    end
+  end
+end

data/lib/aux/carriers/success.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Aux
+  module Carriers
+    class Success
+      # @!attribute [r] code
+      #   @return [Symbol]
+      # @!attribute [r] payload
+      #   @return [Object, nil]
+      attr_reader :code, :payload
+
+      # @param code [Symbol]
+      # @param payload [Object, nil]
+      def initialize(code, payload = nil)
+        @code = code
+        @payload = payload
+      end
+
+      # @return [TrueClass]
+      def succeeded?
+        true
+      end
+
+      # @!method successful?
+      #   @return [TrueClass]
+      alias successful? succeeded?
+
+      # @!method success?
+      #   @return [TrueClass]
+      alias success? succeeded?
+
+      # @return [FalseClass]
+      def failed?
+        false
+      end
+
+      # @!method failure?
+      #   @return [FalseClass]
+      alias failure? failed?
+    end
+  end
+end

data/lib/aux/carriers.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'aux/carriers/success'
+require 'aux/carriers/failure'
+
+module Aux
+  module Carriers
+    private
+
+    # @overload success
+    #   @return [Success]
+    # @overload success(code)
+    #   @param code [Symbol]
+    #   @return [Success]
+    # @overload success(payload)
+    #   @param payload [Object]
+    #   @return [Success]
+    # @overload success(code, payload)
+    #   @param code [Symbol]
+    #   @param payload [Object]
+    #   @return [Success]
+    def success(*arguments)
+      case arguments
+      in [Symbol] | [Symbol, Object]
+        Success.new(*arguments)
+      in [Object]
+        Success.new(:ok, *arguments)
+      else
+        Success.new(:ok)
+      end
+    end
+
+    # @overload failure
+    #   @return [Failure]
+    # @overload failure(code)
+    #   @param code [Symbol]
+    #   @return [Failure]
+    # @overload failure(details)
+    #   @param details [Object]
+    #   @return [Failure]
+    # @overload failure(code, details)
+    #   @param code [Symbol]
+    #   @param details [Object]
+    #   @return [Failure]
+    # @overload failure(code, details, payload)
+    #   @param code [Symbol]
+    #   @param details [Object]
+    #   @param payload [Object]
+    #   @return [Failure]
+    def failure(*arguments)
+      case arguments
+      in [Symbol] | [Symbol, Object] | [Symbol, Object, Object]
+        Failure.new(*arguments)
+      else
+        Failure.new(:internal_server_error, *arguments)
+      end
+    end
+  end
+end

data/lib/aux/pluggable/class_methods.rb

@@ -20,7 +20,7 @@ module Aux
 
         # Configure dependencies that come from the registry
         pluggable.dependencies.each do |dependency|
-          instance.instance_variable_set("@#{dependency.pointer}", dependency.target)
+          instance.instance_variable_set(:"@#{dependency.pointer}", dependency.target)
 
           # The next lines are required to make resolved dependencies available
           # by its reader methods within customized initialization
@@ -28,7 +28,7 @@ module Aux
           # TODO: Discuss whether this is appropriate behaviour
           next if instance.respond_to?(dependency.pointer, true)
 
-          define_method(dependency.pointer) { instance_variable_get("@#{dependency.pointer}") }
+          define_method(dependency.pointer) { instance_variable_get(:"@#{dependency.pointer}") }
           next unless dependency.private
 
           private(dependency.pointer)
@@ -37,7 +37,7 @@ module Aux
         # Configure dependencies that come from the customized initialization procedure
         dependencies_overrides = keyword_arguments.slice(*dependencies_keys)
         dependencies_overrides.each do |pointer, target|
-          instance.instance_variable_set("@#{pointer}", target)
+          instance.instance_variable_set(:"@#{pointer}", target)
         end
 
         # Run the origin's initialization procedure if any other arguments given
@@ -52,24 +52,19 @@ module Aux
 
       # @param initialize [TrueClass, FalseClass]
       # @param memoize [TrueClass, FalseClass]
-      # @param scope [TrueClass, Symbol, String, nil]
+      # @param scope [Symbol, String, TrueClass, nil]
       # @param as [Symbol, String, nil]
       def register(initialize: false, memoize: false, scope: true, as: nil)
-        @_pluggable.register(
-          initialization_required: initialize,
-          memoization_required: memoize,
-          namespace: scope,
-          code: as
-        )
+        @_pluggable.register(initialize, memoize, scope, as)
       end
 
       # @param code [Symbol, String]
-      # @param initialization_block [Block]
+      # @param initialization_block [Proc, nil]
       # @param scope [TrueClass, Symbol, String, nil]
       # @param private [TrueClass, FalseClass]
       # @param as [Symbol, String, nil]
       def resolve(code, initialization_block = nil, scope: true, private: true, as: nil)
-        @_pluggable.resolve(code, initialization_block, namespace: scope, private: private, as: as)
+        @_pluggable.resolve(code, scope, private, as, initialization_block)
       end
     end
   end

data/lib/aux/pluggable/connector.rb

@@ -3,32 +3,26 @@
 module Aux
   module Pluggable
     # Describes the bridge between a pluggable class and the registry
+    # @!visibility private
     class Connector
       # @!attribute [r] dependencies
       #   @return [Array<Dependency>]
       attr_reader :dependencies
 
       # @param subject [Class]
-      # @param registry [Dry::Container]
+      # @param registry [Aux::Registry]
       def initialize(subject, registry)
         @subject = subject
         @registry = registry
         @dependencies = []
-
-        configure
       end
 
-      # @param initialization_required [Boolean] whether the subject requires initialization before use
-      # @param memoization_required [Boolean] whether the subject should be memoized
-      # @param namespace [Symbol] the namespace to register the subject
-      # @param code [Symbol] an alternate name
-      def register(initialization_required: nil, memoization_required: nil, namespace: nil, code: nil)
-        configure(
-          initialization_required: initialization_required,
-          memoization_required: memoization_required,
-          namespace: namespace,
-          code: code
-        )
+      # @param initialization_required [TrueClass, FalseClass] whether the subject requires initialization before use
+      # @param memoization_required [TrueClass, FalseClass] whether the subject should be memoized
+      # @param namespace [Symbol, String, TrueClass, nil] the namespace to register the subject
+      # @param code [Symbol, String, nil] an alternate name
+      def register(initialization_required, memoization_required, namespace, code)
+        configure(initialization_required, memoization_required, namespace, code)
 
         # Register the subject in the registry using the provided options
         @registry.register(@cipher, memoize: @memoization_required) do
@@ -37,41 +31,41 @@ module Aux
       end
 
       # @param code [Symbol, String] the name of the dependency
-      # @param initialization_block [Proc] an optional block used to initialize the dependency
-      # @param namespace [TrueClass, Symbol, String, nil] whether to resolve the dependency in the same namespace
+      # @param namespace [Symbol, String, TrueClass, nil] whether to resolve the dependency in the same namespace
       # @param private [TrueClass, FalseClass] whether to make the dependency private
-      # @param as [Symbol] an internal alias name for the dependency
-      # rubocop:disable Layout/LineLength, Metrics/AbcSize, Metrics/MethodLength
-      def resolve(code, initialization_block = nil, namespace: true, private: true, as: nil)
-        cipher = Utilities.dependency_cipher(@subject.name, scope: namespace, code: code)
-        load_class(cipher) unless @registry.key?(cipher)
+      # @param as [Symbol, String, nil] an internal alias name for the dependency
+      # @param initialization_block [Proc, nil] an optional block used to initialize the dependency
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def resolve(code, namespace, private, as, initialization_block = nil)
+        cipher = Utilities.dependency_cipher(@subject.name, namespace, code)
+        load_class(cipher)
 
-        dependency = Dependency.new(@registry.resolve(cipher), initialization_block, pointer: as || code, private: private)
+        dependency = Dependency.new(@registry.resolve(cipher), as || code, private, initialization_block)
         @dependencies.push(dependency)
 
         if @initialization_required
           @subject.class_eval do
-            define_method(dependency.pointer) { instance_variable_get("@#{dependency.pointer}") }
+            define_method(dependency.pointer) { instance_variable_get(:"@#{dependency.pointer}") }
             private(dependency.pointer) if dependency.private
           end
         else
-          @subject.instance_variable_set("@#{dependency.pointer}", dependency.target)
+          @subject.instance_variable_set(:"@#{dependency.pointer}", dependency.target)
           @subject.singleton_class.class_eval do
-            define_method(dependency.pointer) { instance_variable_get("@#{dependency.pointer}") }
+            define_method(dependency.pointer) { instance_variable_get(:"@#{dependency.pointer}") }
             private(dependency.pointer) if dependency.private
           end
         end
       end
-      # rubocop:enable Layout/LineLength, Metrics/AbcSize, Metrics/MethodLength
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
       private
 
-      # @param initialization_required [TrueClass, FalseClass, nil]
-      # @param memoization_required [TrueClass, FalseClass, nil]
-      # @param namespace [Symbol, String, nil]
+      # @param initialization_required [TrueClass, FalseClass]
+      # @param memoization_required [TrueClass, FalseClass]
+      # @param namespace [TrueClass, Symbol, String, nil]
       # @param code [Symbol, String, nil]
-      def configure(initialization_required: nil, memoization_required: nil, namespace: nil, code: nil)
-        @cipher = Utilities.dependency_cipher(@subject.name, scope: namespace, code: code)
+      def configure(initialization_required, memoization_required, namespace, code)
+        @cipher = Utilities.dependency_cipher(@subject.name, namespace, code)
         @initialization_required = initialization_required
         @memoization_required = memoization_required
         @namespace = namespace

data/lib/aux/pluggable/dependency.rb

@@ -3,6 +3,7 @@
 module Aux
   module Pluggable
     # Describes the dependency and its preferences
+    # @!visibility private
     class Dependency
       # @!attribute [r] target
       #   @return [Object]
@@ -10,14 +11,14 @@ module Aux
       #   @return [Symbol, String]
       # @!attribute [r] private
       #   @return [Boolean]
-      attr_reader :pointer, :target, :private
+      attr_reader :target, :pointer, :private
 
       # @param target [Object]
-      # @param initialization_block [Proc, nil]
       # @param pointer [Symbol, String]
       # @param private [Boolean]
-      def initialize(target, initialization_block = nil, pointer:, private:)
-        @target = initialization_block ? initialization_block.call(target) : target
+      # @param initialization_block [Proc, nil]
+      def initialize(target, pointer, private, initialization_block = nil)
+        @target = initialization_block&.call(target) || target
         @pointer = pointer
         @private = private
       end

data/lib/aux/pluggable/utilities.rb

@@ -3,28 +3,29 @@
 module Aux
   module Pluggable
     # Random methods for internal usage
+    # @!visibility private
     module Utilities
       # First, we need to determine the appropriate namespace (also called the scope) in which to resolve something.
       # By default, we assume that the developers want to resolve a dependency from the same namespace as the
       # referencing class. Another approach is to allow developers to set the correct scope themselves.
       #
-      # @param subject [ClassName]
-      # @param scope [TrueClass, Symbol, String, nil]
-      # @param code [TrueClass, Symbol, String, nil]
+      # @param subject [String]
+      # @param scope [Symbol, String, TrueClass, nil]
+      # @param code [Symbol, String, nil]
       # @return [String]
-      def self.dependency_cipher(subject, scope: nil, code: nil)
+      def self.dependency_cipher(subject, scope, code)
         native_cipher = dependency_native_cipher(subject)
         native_cipher_partitions = native_cipher.rpartition('.')
-        scope = scope == true ? native_cipher_partitions.first : scope
-        code = code.nil? ? native_cipher_partitions.last : code
+        scope = native_cipher_partitions.first if scope == true
+        code = native_cipher_partitions.last if code.nil?
 
         [scope, code].reject { |part| part.nil? || part.empty? }.join('.')
       end
 
-      # @param subject [ClassName]
+      # @param subject [String]
       # @return [String]
       def self.dependency_native_cipher(subject)
-        subject.dup.gsub(/::/, '.').gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
+        subject.dup.gsub('::', '.').gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
       end
     end
   end

data/lib/aux/pluggable.rb

@@ -4,11 +4,14 @@ require 'aux/pluggable/class_methods'
 require 'aux/pluggable/connector'
 require 'aux/pluggable/dependency'
 require 'aux/pluggable/utilities'
+require 'aux/registry'
 
 module Aux
   # Describes interface that makes any class able to register itself as well as resolve dependencies
   # rubocop:disable Style/ClassVars
   module Pluggable
+    @@registry = Aux::Registry.new
+
     # Extends the including class with ClassMethods and initializes a new Connector instance
     # @param base [Class] the class that includes this module
     def self.included(base)
@@ -19,12 +22,19 @@ module Aux
       end
     end
 
-    # @param registry [Dry::Container]
+    # @yield configure the module
+    # @yieldparam pluggable [Module<Aux::Pluggable>]
+    # @yieldparam registry [Aux::Registry]
+    def self.configure
+      yield(self, @@registry) if block_given?
+    end
+
+    # @param registry [Aux::Registry]
     def self.registry=(registry)
       @@registry = registry
     end
 
-    # @return [Dry::Container]
+    # @return [Aux::Registry]
     def self.registry
       @@registry
     end

data/lib/aux/registry/entry.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Aux
+  class Registry
+    # Describes a registered dependency
+    # @!visibility private
+    class Entry
+      # @param constructor [Proc]
+      # @param memoization_required [TrueClass, FalseClass]
+      def initialize(constructor, memoization_required)
+        @constructor = constructor
+        @memoization_required = memoization_required
+
+        @mutex = Thread::Mutex.new
+      end
+
+      # @return [Object]
+      def call
+        return @constructor.call unless @memoization_required
+
+        @call ||= @mutex.synchronize do
+          @constructor.call
+        end
+      end
+    end
+  end
+end

data/lib/aux/registry.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'aux/registry/entry'
+require 'concurrent/map'
+
+module Aux
+  # Registry for dependency injection
+  class Registry
+    def initialize
+      @prototypes = ::Concurrent::Map.new
+    end
+
+    # @param key [Symbol, String]
+    # @param memoize [TrueClass, FalseClass]
+    # @param constructor [Proc]
+    def register(key, memoize: false, &constructor)
+      @prototypes.put(key.to_s, Entry.new(constructor, memoize))
+    end
+
+    # @param key [Symbol, String]
+    # @return [Object]
+    def resolve(key)
+      @prototypes.fetch(key.to_s).call
+    end
+
+    # @param key [Symbol, String]
+    # @return [TrueClass, FalseClass]
+    def key?(key)
+      @prototypes.key?(key.to_s)
+    end
+  end
+end

data/lib/aux/validations/error.rb

@@ -6,22 +6,22 @@ module Aux
     class Error
       # @!attribute [r] attribute
       #   @return [Symbol]
-      # @!attribute [r] type
-      #   @return [Symbol]
       # @!attribute [r] scope
       #   @return [String]
+      # @!attribute [r] type
+      #   @return [Symbol]
       # @!attribute [r] details
       #   @return [Hash]
-      attr_reader :attribute, :type, :scope, :details
+      attr_reader :attribute, :scope, :type, :details
 
       # @param attribute [Symbol]
-      # @param type [Symbol]
       # @param scope [String]
+      # @param type [Symbol]
       # @param details [Hash]
-      def initialize(attribute, type, scope, **details)
+      def initialize(attribute, scope, type, **details)
         @attribute = attribute
-        @type = type
         @scope = scope
+        @type = type
         @details = details
       end
     end

data/lib/aux/validations/error_handler.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Aux
+  module Validations
+    # Describes methods that represent validation errors in simple structures pretty enough for the API response.
+    module ErrorHandler
+      private
+
+      DEFAULT_ERROR_SCOPE_PREFIX = 'errors'
+      GENERIC_ERROR_SCOPE = 'errors.generic'
+
+      # @overload format_errors(error_batch, scope)
+      #   @param error_batch [Array]
+      #   @param scope [Symbol, String, nil]
+      #   @raise [ArgumentError]
+      #   @return [Array<Hash>]
+      # @overload format_errors(error_collection, scope)
+      #   @param error_collection [Errors]
+      #   @param scope [Symbol, String, nil]
+      #   @raise [ArgumentError]
+      #   @return [Array<Hash>]
+      # @overload format_errors(error, scope)
+      #   @param scope [Symbol, String, nil]
+      #   @param error [Error]
+      #   @raise [ArgumentError]
+      #   @return [Hash]
+      def format_errors(payload, scope = nil)
+        case payload
+        when Array
+          format_error_batch(payload, scope)
+        when Errors
+          format_error_collection(payload, scope)
+        when Error
+          format_error(payload, scope)
+        else
+          raise ArgumentError
+        end
+      end
+
+      # @param batch [Array<Error, Errors>]
+      # @param scope [Symbol, String, nil]
+      # @return [Array<Hash>]
+      def format_error_batch(batch, scope = nil)
+        batch.flat_map { |element| format_errors(element, scope) }
+      end
+
+      # @param collection [Errors]
+      # @param scope [Symbol, String, nil]
+      def format_error_collection(collection, scope = nil)
+        return format_primary_error_collection(collection, scope || collection.scope) unless collection.attribute
+
+        format_secondary_error_collection(collection, "#{scope}.#{collection.attribute}")
+      end
+
+      # @param collection [Errors]
+      # @param scope [Symbol, String, nil]
+      # @return [Array<Hash>]
+      def format_primary_error_collection(collection, scope = nil)
+        collection.group_by_attribute.map do |attribute, entities|
+          {
+            kind: entities.all?(Error) ? 'collection' : 'batch',
+            attribute: attribute,
+            errors: format_errors(entities, scope)
+          }
+        end
+      end
+
+      # @param collection [Errors]
+      # @param scope [Symbol, String, nil]
+      # @return [Array<Hash>]
+      def format_secondary_error_collection(collection, scope = nil)
+        collection.group_by_attribute.flat_map do |_attribute, items|
+          format_errors(items.one? ? items.first : items, scope)
+        end
+      end
+
+      # @param error [Error]
+      # @param scope [Symbol, String, nil]
+      # @return [Hash]
+      def format_error(error, scope = nil)
+        {
+          type: error.type,
+          details: error.details,
+          message: format_message(error, scope)
+        }
+      end
+
+      # @param error [Error]
+      # @param scope [Symbol, String, nil]
+      # @return [String]
+      def format_message(error, scope = nil)
+        scope ? format_secondary_message(error, scope) : format_primary_message(error)
+      end
+
+      # @param error [Error]
+      # @return [String]
+      def format_primary_message(error)
+        I18n.translate(
+          error.type,
+          scope: "#{self.class::DEFAULT_ERROR_SCOPE_PREFIX}.#{error.scope}.#{error.attribute}",
+          default: proc { format_fallback_message(error) },
+          **error.details
+        )
+      end
+
+      # @param error [Error]
+      # @param scope [Symbol, String, nil]
+      # @return [String]
+      def format_secondary_message(error, scope)
+        I18n.translate(
+          error.type,
+          scope: "#{self.class::DEFAULT_ERROR_SCOPE_PREFIX}.#{scope}.#{error.attribute}",
+          default: proc { format_primary_message(error) },
+          **error.details
+        )
+      end
+
+      # @param error [Error]
+      # @return [String]
+      def format_fallback_message(error)
+        I18n.translate(error.type, scope: self.class::GENERIC_ERROR_SCOPE, default: error.type)
+      end
+    end
+  end
+end

data/lib/aux/validations/errors.rb

@@ -1,11 +1,8 @@
 # frozen_string_literal: true
 
-require 'aux/validations/error'
-require 'aux/validations/errors_tree_presenter'
-
 module Aux
   module Validations
-    # Describes a batch of errors that can be initialized using an attribute name or an object that should be validated
+    # Describes a collection of errors that can be initialized with an attribute name or an object to be validated
     class Errors
       # @!attribute [r] scope
       #   @return [String, nil]
@@ -14,16 +11,13 @@ module Aux
       attr_reader :scope, :attribute
 
       # @overload initialize(subject)
-      #   @param base [Object]
-      #   @return [self]
+      #   @param subject [Object]
       # @overload initialize(attribute, errors)
-      #   Use this approach to handle nested errors
       #   @param attribute [Symbol]
-      #   @param errors [Aux::Validation::Errors]
-      #   @return [self]
-      def initialize(base, errors = [])
-        @scope = base.is_a?(Symbol) ? nil : base.class.name.underscore.tr('/', '.')
-        @attribute = base.is_a?(Symbol) ? base : nil
+      #   @param errors [Errors]
+      def initialize(subject, errors = [])
+        @scope = subject.is_a?(Symbol) ? nil : subject.class.name.underscore.tr('/', '.')
+        @attribute = subject.is_a?(Symbol) ? subject : nil
         @errors = errors
       end
 
@@ -34,35 +28,25 @@ module Aux
       #   @raise [StandardError]
       # @overload add(attribute, errors)
       #   @param attribute [Symbol]
-      #   @param errors [Array<Aux::Validations::Errors, Aux::Validations::Error>]
+      #   @param errors [Array<Errors, Error>]
       #   @raise [StandardError]
       # @overload add(attribute, errors)
       #   @param attribute [Symbol]
-      #   @param errors [Aux::Validations::Errors]
+      #   @param errors [Errors]
       #   @raise [StandardError]
-      def add(attribute, payload, **details)
-        case payload
+      def add(attribute, subject, **details)
+        case subject
         when Symbol
-          add_error(attribute, payload, **details)
+          add_error(attribute, subject, **details)
         when Array
-          add_nested_error(attribute, payload)
-        when Aux::Validations::Errors
-          add_nested_error(attribute, [payload])
+          add_nested_error(attribute, subject)
+        when Errors
+          add_nested_error(attribute, [subject])
         else
-          raise StandardError, :unsupported_type
+          raise(ArgumentError, "Unsupported argument given (#{subject.class})")
         end
       end
 
-      # @return [Hash]
-      def tree
-        tree_presenter.render(self)
-      end
-
-      # @return [Hash]
-      def group_by_attribute
-        errors.group_by(&:attribute)
-      end
-
       def clear
         self.errors = []
       end
@@ -72,25 +56,20 @@ module Aux
         errors.empty?
       end
 
+      # @param block [Proc]
       def map(&block)
         errors.map(&block)
       end
 
-      # @return [Array<Aux::Validations::Error>]
-      def all
-        errors.map do |error|
-          if error.is_a?(Array)
-            error.map { |e| e.respond_to?(:all) ? e.all : e }
-          else
-            error.respond_to?(:all) ? error.all : error
-          end
-        end.flatten
+      # @return [Hash<Symbol, Array>]
+      def group_by_attribute
+        errors.group_by(&:attribute)
       end
 
       private
 
       # @!attribute [rw] errors
-      #   @return [Array<Aux::Validations::Errors, Aux::Validations::Error>]
+      #   @return [Array<Error, Errors>]
       attr_accessor :errors
 
       # @param attribute [Symbol]
@@ -101,7 +80,7 @@ module Aux
       end
 
       # @param attribute [Symbol]
-      # @param nested_errors [Aux::Validations::Errors]
+      # @param nested_errors [Errors]
       def add_nested_error(attribute, nested_errors)
         errors.push(build_nested_error(attribute, nested_errors))
       end
@@ -109,26 +88,21 @@ module Aux
       # @param attribute [Symbol]
       # @param type [Symbol]
       # @param details [Hash]
-      # @return [Aux::Validations::Error]
+      # @return [Error]
       def build_error(attribute, type, **details)
-        errors_factory.new(attribute, type, scope, **details)
+        factory.new(attribute, scope, type, **details)
       end
 
       # @param attribute [Symbol] 3
-      # @param errors [Aux::Validations::Errors]
-      # @return [Aux::Validations::Errors]
+      # @param errors [Errors]
+      # @return [Errors]
       def build_nested_error(attribute, errors)
         self.class.new(attribute, errors)
       end
 
-      # @return [Class<Aux::Validations::ErrorsTreePresenter>]
-      def tree_presenter
-        Aux::Validations::ErrorsTreePresenter
-      end
-
-      # @return [Class<Aux::Validations::Error>]
-      def errors_factory
-        Aux::Validations::Error
+      # @return [Class<Error>]
+      def factory
+        Error
       end
     end
   end

data/lib/aux/validations.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
+require 'active_model'
 require 'active_support'
-require 'active_model/validations/validates'
+require 'aux/validations/error'
 require 'aux/validations/errors'
+require 'aux/validations/error_handler'
 
 module Aux
   # Describes enhancement of {::ActiveModel::Validations}

data/lib/aux/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Aux
-  VERSION = '0.1.1'
+  VERSION = '0.3.0'
 end

data/lib/aux.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'aux/carriers'
 require 'aux/pluggable'
 require 'aux/validations'
 

metadata

@@ -1,109 +1,87 @@
 --- !ruby/object:Gem::Specification
 name: aux
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Evgeny Boyko
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-18 00:00:00.000000000 Z
+date: 2024-08-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: activemodel
+  name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.1'
-    - - "<"
+        version: '1.2'
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '8'
+        version: 1.2.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.1'
-    - - "<"
+        version: '1.2'
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '8'
+        version: 1.2.3
 - !ruby/object:Gem::Dependency
-  name: dry-container
+  name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.0
-    - - "<="
+        version: '6.1'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '0.11'
+        version: '8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.0
-    - - "<="
-      - !ruby/object:Gem::Version
-        version: '0.11'
-- !ruby/object:Gem::Dependency
-  name: zeitwerk
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.5'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.5'
-- !ruby/object:Gem::Dependency
-  name: rubocop
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.36.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
+        version: '6.1'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 1.36.0
-description: 
+        version: '8'
+description:
 email:
 - eboyko@eboyko.ru
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- MIT-LICENSE
 - README.md
 - aux.gemspec
 - lib/aux.rb
+- lib/aux/carriers.rb
+- lib/aux/carriers/failure.rb
+- lib/aux/carriers/success.rb
 - lib/aux/pluggable.rb
 - lib/aux/pluggable/class_methods.rb
 - lib/aux/pluggable/connector.rb
 - lib/aux/pluggable/dependency.rb
 - lib/aux/pluggable/utilities.rb
+- lib/aux/registry.rb
+- lib/aux/registry/entry.rb
 - lib/aux/validations.rb
 - lib/aux/validations/error.rb
+- lib/aux/validations/error_handler.rb
 - lib/aux/validations/errors.rb
-- lib/aux/validations/errors_tree_presenter.rb
 - lib/aux/version.rb
 homepage: https://github.com/eboyko/aux
 licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -119,7 +97,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.1.2
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Supplementary tools for more effective development
 test_files: []

data/lib/aux/validations/errors_tree_presenter.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module Aux
-  module Validations
-    # Describes tree structure presentation scenario of errors
-    class ErrorsTreePresenter
-      class << self
-        # @return [Array, Hash, Aux::Validations::Error]
-        def render(payload)
-          case payload
-          when Array
-            process_array(payload)
-          when Aux::Validations::Errors
-            render_collection(payload)
-          when Aux::Validations::Error
-            payload
-          end
-        end
-
-        private
-
-        # @param errors [Array]
-        # @return [Array]
-        def process_array(errors)
-          errors.map { |item| render(item) }.flatten
-        end
-
-        # @param errors [Aux::Validations::Errors]
-        # @return [Array, Hash]
-        def render_collection(errors)
-          errors.attribute ? process_attribute_errors(errors) : process_errors(errors)
-        end
-
-        # @param errors [Aux::Validations::Errors]
-        # @return [Hash]
-        def process_errors(errors)
-          errors.group_by_attribute.transform_values do |items|
-            render(items.one? ? items.first : items)
-          end
-        end
-
-        # @param errors [Aux::Validations::Errors]
-        # @return [Array]
-        def process_attribute_errors(errors)
-          errors.group_by_attribute.map { |_attribute, items| render(items) }.flatten
-        end
-      end
-    end
-  end
-end