aux 0.0.2 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c812c16ef07f3e6e43157d04b2e22bd2b72460433e344a89bbb36568ea082f54
-  data.tar.gz: b5205ffd09fde764555e19f6772f05f19f81453a8ceea73150cdf042132e5237
+  metadata.gz: acf9da895d77d8ab39cc92765e586e69e0300e15cedc201fdd18a30a02221d4c
+  data.tar.gz: c6aa3892d3a1691f2e0192a3094c33838a5e5b40121538b06862e1c7491c7190
 SHA512:
-  metadata.gz: 7cac5ece74ce3d842c856140f3340d7543bf195408e834b7505e18e18418023506954f22ddb3de0c543252162a61f4c22180539bcd238bb4f6114c6f6e0a57d1
-  data.tar.gz: 0f5350206dde4094116e1706c26e76017cd2864eaa67aa13f03eda8d3a959ce96aead7dc4cdb7ab7f9570a2946f337daf0942dfb2cfd76ff8c7e73ff76b616a3
+  metadata.gz: c10a70b5b35a62161e4f6c48362fda7bc51e08a046c638ac3d8a8311fac53648fc1bdcd526e0c4d7302e1c9ce36c80d97f845dc0fa5d32f9e8ebc1332aad408d
+  data.tar.gz: ae97078e7e7cc0d627711a1c147befecadcfa70e057376378402d59a8dda844ad63f4596a10fd1ee26c594f0db8f8189d0bfdb6e9a3962b557899747503b3c35

data/aux.gemspec

@@ -0,0 +1,22 @@
+require_relative 'lib/aux/version'
+
+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.authors = ['Evgeny Boyko']
+  specification.email = ['eboyko@eboyko.ru']
+  specification.homepage = 'https://github.com/eboyko/aux'
+
+  specification.add_dependency 'activemodel', '~> 6.1.6'
+
+  specification.add_development_dependency 'dry-container', '~> 0.11.0'
+  specification.add_development_dependency 'rubocop', '~> 1.36.0'
+
+  specification.required_ruby_version = '>= 2.7.1'
+  specification.metadata['rubygems_mfa_required'] = 'true'
+
+  specification.license = 'MIT'
+end

data/lib/aux/pluggable/class_methods.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Aux
+  module Pluggable
+    # Describes methods that would be inherited by pluggable classes
+    module ClassMethods
+      # @param dependencies [Hash{Symbol => Object}]
+      def new(**dependencies)
+        instance = allocate
+
+        # Configure dependencies that come from the registry
+        @_dependencies.each do |name, dependency|
+          instance.instance_variable_set("@#{name}", dependency)
+        end
+
+        # Configure dependencies that come from the customized initialization procedure
+        dependencies.each do |name, dependency|
+          instance.instance_variable_set("@#{name}", dependency) if @_dependencies.include?(name)
+        end
+
+        # Run the rest of customized initialization procedure
+        instance.send(:initialize, **dependencies)
+
+        instance
+      end
+
+      private
+
+      # @param initialize [TrueClass, FalseClass]
+      # @param memoize [TrueClass, FalseClass]
+      # @param scope [TrueClass, Symbol, String, nil]
+      # @param as [Symbol, String, nil]
+      def register(initialize: false, memoize: false, scope: true, as: nil)
+        dependency_cipher = Utilities.dependency_cipher(name, scope: scope, code: as)
+        @_registry.register(dependency_cipher, memoize: memoize) { initialize ? new : self }
+      end
+
+      # @param code [Symbol, String]
+      # @param initialization_block [Proc, nil]
+      # @param scope [TrueClass, Symbol, String, nil]
+      # @param as [Symbol, String]
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def resolve(code, initialization_block = nil, scope: true, as: nil)
+        dependency_cipher = Utilities.dependency_cipher(name, scope: scope, code: code)
+        dependency_alias = as || code
+
+        # The process of preloading classes is a bit messy. Therefore, why we wrap the dependency in a Proc.
+        # This allows us not to worry about the absence of the referenced class in the registry during assembly.
+        # Using an initialization block can be convenient in some cases, for example, to resolve some
+        # of the global settings without accessing the whole thing.
+        @_dependencies[dependency_alias] =
+          if initialization_block
+            -> { initialization_block.call(@_registry.resolve(dependency_cipher)) }
+          else
+            -> { @_registry.resolve(dependency_cipher) }
+          end
+
+        # The final step is to declare instance variables and methods to access them.
+        instance_eval do
+          define_method(dependency_alias) do
+            if instance_variable_get("@#{dependency_alias}").is_a?(Proc)
+              instance_variable_get("@#{dependency_alias}").call
+            else
+              instance_variable_get("@#{dependency_alias}")
+            end
+          end
+
+          private dependency_alias
+        end
+
+        singleton_class.class_eval do
+          define_method(dependency_alias) { @_dependencies[dependency_alias].call }
+          private dependency_alias
+        end
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+    end
+  end
+end

data/lib/aux/pluggable/registration.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Aux
+  module Pluggable
+    # Describes a wrapper for registry data
+    class Registration
+      # @!attribute [r] name
+      #   @return [Symbol, String]
+      # @!attribute [r] initialization_required
+      #   @return [TrueClass, FalseClass]
+      # @!attribute [r] memoization_required
+      #   @return [TrueClass, FalseClass]
+      attr_reader :name, :initialization_required, :memoization_required
+
+      # @param name [Symbol, String]
+      # @param initialization_required [TrueClass, FalseClass]
+      # @param memoization_required [TrueClass, FalseClass]
+      def initialize(name, initialization_required, memoization_required)
+        @name = name
+        @initialization_required = initialization_required
+        @memoization_required = memoization_required
+      end
+    end
+  end
+end

data/lib/aux/pluggable/utilities.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Aux
+  module Pluggable
+    # Random methods for internal usage
+    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 class_name [Class]
+      # @param scope [TrueClass, Symbol, String, nil]
+      # @param code [TrueClass, Symbol, String, nil]
+      # @return [String]
+      def self.dependency_cipher(class_name, scope: nil, code: nil)
+        native_cipher = dependency_native_cipher(class_name)
+        native_cipher_partitions = native_cipher.rpartition('.')
+        scope = scope.is_a?(TrueClass) ? native_cipher_partitions.first : scope
+        code = code.nil? ? native_cipher_partitions.last : code
+
+        [scope, code].reject { |part| part.nil? || part.empty? }.join('.')
+      end
+
+      # @param class_name [Class]
+      # @return [String]
+      def self.dependency_native_cipher(class_name)
+        class_name.dup.gsub(/::/, '.').gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
+      end
+    end
+  end
+end

data/lib/aux/pluggable.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'aux/pluggable/class_methods'
+require 'aux/pluggable/utilities'
+
+module Aux
+  # Describes interface that makes any class able to register itself as well as resolve dependencies
+  module Pluggable
+    # @param base [Class]
+    def self.included(base)
+      base.extend(ClassMethods)
+
+      base.class_eval do
+        @_registry = @@registry
+        @_dependencies = {}
+      end
+    end
+
+    # @param registry [Dry::Container]
+    def self.registry=(registry)
+      @@registry = registry
+    end
+
+    # @return [Dry::Container]
+    def self.registry
+      @@registry
+    end
+  end
+end

data/lib/aux/validations/error.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Aux
+  module Validations
+    # Describes a single validation error
+    class Error
+      # @!attribute [r] attribute
+      #   @return [Symbol]
+      # @!attribute [r] type
+      #   @return [Symbol]
+      # @!attribute [r] scope
+      #   @return [String]
+      # @!attribute [r] details
+      #   @return [Hash]
+      attr_reader :attribute, :type, :scope, :details
+
+      # @param attribute [Symbol]
+      # @param type [Symbol]
+      # @param scope [String]
+      # @param details [Hash]
+      def initialize(attribute, type, scope, **details)
+        @attribute = attribute
+        @type = type
+        @scope = scope
+        @details = details
+      end
+    end
+  end
+end

data/lib/aux/validations/errors.rb

@@ -0,0 +1,135 @@
+# 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
+    class Errors
+      # @!attribute [r] scope
+      #   @return [String, nil]
+      # @!attribute [r] attribute
+      #   @return [Symbol, nil]
+      attr_reader :scope, :attribute
+
+      # @overload initialize(subject)
+      #   @param base [Object]
+      #   @return [self]
+      # @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
+        @errors = errors
+      end
+
+      # @overload add(attribute, type, **details)
+      #   @param attribute [Symbol]
+      #   @param type [Symbol]
+      #   @param details [Hash]
+      #   @raise [StandardError]
+      # @overload add(attribute, errors)
+      #   @param attribute [Symbol]
+      #   @param errors [Array<Aux::Validations::Errors, Aux::Validations::Error>]
+      #   @raise [StandardError]
+      # @overload add(attribute, errors)
+      #   @param attribute [Symbol]
+      #   @param errors [Aux::Validations::Errors]
+      #   @raise [StandardError]
+      def add(attribute, payload, **details)
+        case payload
+        when Symbol
+          add_error(attribute, payload, **details)
+        when Array
+          add_nested_error(attribute, payload)
+        when Aux::Validations::Errors
+          add_nested_error(attribute, [payload])
+        else
+          raise StandardError, :unsupported_type
+        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
+
+      # @return [Boolean]
+      def empty?
+        errors.empty?
+      end
+
+      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
+      end
+
+      private
+
+      # @!attribute [rw] errors
+      #   @return [Array<Aux::Validations::Errors, Aux::Validations::Error>]
+      attr_accessor :errors
+
+      # @param attribute [Symbol]
+      # @param type [Symbol]
+      # @param details [Hash]
+      def add_error(attribute, type, **details)
+        errors.push(build_error(attribute, type, **details))
+      end
+
+      # @param attribute [Symbol]
+      # @param nested_errors [Aux::Validations::Errors]
+      def add_nested_error(attribute, nested_errors)
+        errors.push(build_nested_error(attribute, nested_errors))
+      end
+
+      # @param attribute [Symbol]
+      # @param type [Symbol]
+      # @param details [Hash]
+      # @return [Aux::Validations::Error]
+      def build_error(attribute, type, **details)
+        errors_factory.new(attribute, type, scope, **details)
+      end
+
+      # @param attribute [Symbol] 3
+      # @param errors [Aux::Validations::Errors]
+      # @return [Aux::Validations::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
+      end
+    end
+  end
+end

data/lib/aux/validations/errors_tree_presenter.rb

@@ -0,0 +1,50 @@
+# 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

data/lib/aux/validations.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'aux/validations/errors'
+
+module Aux
+  # Describes enhancement of {ActiveModel::Validations}
+  module Validations
+    extend ActiveSupport::Concern
+    include ActiveModel::Validations
+
+    # @return [Aux::Validations::Errors]
+    def errors
+      @errors ||= Aux::Validations::Errors.new(self)
+    end
+  end
+end

data/lib/aux/version.rb

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

data/lib/aux.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'aux/pluggable'
+require 'aux/validations'
+
+# Define module that includes auxiliaries
+module Aux; end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aux
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
 platform: ruby
 authors:
 - Evgeny Boyko
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-09-12 00:00:00.000000000 Z
+date: 2023-03-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -25,19 +25,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 6.1.6
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: dry-container
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 6.1.6
-  type: :runtime
+        version: 0.11.0
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 6.1.6
+        version: 0.11.0
+- !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:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.36.0
 description: 
 email:
 - eboyko@eboyko.ru
@@ -46,6 +60,17 @@ extensions: []
 extra_rdoc_files: []
 files:
 - README.md
+- aux.gemspec
+- lib/aux.rb
+- lib/aux/pluggable.rb
+- lib/aux/pluggable/class_methods.rb
+- lib/aux/pluggable/registration.rb
+- lib/aux/pluggable/utilities.rb
+- lib/aux/validations.rb
+- lib/aux/validations/error.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