servactory 2.14.1 → 2.15.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee6b7f861c6725a1cc1addd81413b0d84eef974ee2290543145293561b9b23d8
-  data.tar.gz: 855d74bbded65bd281bbb9c8018e7e7d0272d555593b0b78464432cda42481e7
+  metadata.gz: c53c25c36b576e8a9c501b60a5ad223bbbfc3001dbf2186fd4086d937cbae084
+  data.tar.gz: 6c08533b7fa4562860d53d2489c98e67674697c6442901c54d6aff1c98cd4793
 SHA512:
-  metadata.gz: 34ba463f5c90df781dbc93761e7f73b5776532fa53ba5d6ff663e4c00d9fd5ffa744fe5a8f62704cd84496f6ee10b277b674b7c2c9e2262f02d6fead30a2cfc8
-  data.tar.gz: 32dbeb464202b1e3e64eb62677e3ed61ba8acd95616ac8098a269869e099946c2030bc9272124727288eb166d3f58414ca812cc27a173292af6d168d0453a749
+  metadata.gz: e4ca873a1c77929813b5d7bb8f8e380cbfbacd58c7d249fdc629f12d95ef5b76c5920698bbf0a1accfd400d707c39b7550a4d7f1e002258419c6b5fc31d85a75
+  data.tar.gz: a83ebf3a2a6564d775c5d128c0939cf23c7d90041fd119137696ef7d400592b33d10cb205f4e2f997fe74da351e6f8aef40ec7c30d1a9d208d478965f22451a8

data/lib/servactory/actions/dsl.rb

@@ -86,11 +86,11 @@ module Servactory
           collection_of_stages << current_stage
         end
 
-        def method_missing(name, ...)
-          return method_missing_for_action_aliases(...) if config.action_aliases.include?(name)
+        def method_missing(name, *args, &block)
+          return method_missing_for_action_aliases(*args) if config.action_aliases.include?(name)
 
           if (action_shortcut = config.action_shortcuts.find_by(name:)).present?
-            return method_missing_for_shortcuts_for_make(action_shortcut, ...)
+            return method_missing_for_shortcuts_for_make(action_shortcut, *args)
           end
 
           super

data/lib/servactory/context/workspace/internals.rb

@@ -53,7 +53,7 @@ module Servactory
           @context.send(:servactory_service_warehouse).assign_internal(internal.name, value)
         end
 
-        def fetch_with(name:, &block) # rubocop:disable Metrics/AbcSize, Lint/UnusedMethodArgument
+        def fetch_with(name:, &block) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Lint/UnusedMethodArgument
           internal_name = @context.class.config.predicate_methods_enabled? ? name.to_s.chomp("?").to_sym : name
           internal = @collection_of_internals.find_by(name: internal_name)
 
@@ -61,6 +61,12 @@ module Servactory
 
           internal_value = @context.send(:servactory_service_warehouse).fetch_internal(internal.name)
 
+          Servactory::Maintenance::Attributes::Tools::Validation.validate!(
+            context: @context,
+            attribute: internal,
+            value: internal_value
+          )
+
           if name.to_s.end_with?("?") && @context.class.config.predicate_methods_enabled?
             Servactory::Utils.query_attribute(internal_value)
           else

data/lib/servactory/dsl.rb

@@ -2,7 +2,19 @@
 
 module Servactory
   module DSL
-    @extensions = []
+    module Extensions
+      def self.registry
+        @registry ||= []
+      end
+
+      def self.register(*extensions)
+        registry.concat(extensions)
+      end
+
+      def self.clear
+        @registry = []
+      end
+    end
 
     def self.included(base)
       base.include(Configuration::DSL)
@@ -12,21 +24,15 @@ module Servactory
       base.include(Internals::DSL)
       base.include(Outputs::DSL)
 
-      extensions.each { |extension| base.include(extension) }
+      Extensions.registry.each { |extension| base.include(extension) }
 
       base.include(Actions::DSL)
     end
 
     def self.with_extensions(*extensions)
-      @extensions = extensions
-
+      Extensions.clear
+      Extensions.register(*extensions)
       self
     end
-
-    def self.extensions
-      @extensions
-    end
-
-    private_class_method :extensions
   end
 end

data/lib/servactory/exceptions/failure.rb

@@ -14,6 +14,20 @@ module Servactory
 
         super(message)
       end
+
+      def method_missing(name, *_args) # rubocop:disable Naming/PredicateMethod
+        @type == normalize_method_name(name)
+      end
+
+      def respond_to_missing?(name, *)
+        @type == normalize_method_name(name) || super
+      end
+
+      private
+
+      def normalize_method_name(name)
+        name.to_s.chomp("?").to_sym
+      end
     end
   end
 end

data/lib/servactory/info/builder.rb

@@ -12,90 +12,113 @@ module Servactory
       end
 
       def build(collection_of_inputs:, collection_of_internals:, collection_of_outputs:, config:)
-        dynamic_options = config.input_option_helpers.dynamic_options
-
-        build_inputs_with(collection_of_inputs:, dynamic_options:)
-        build_internals_with(collection_of_internals:, dynamic_options:)
-        build_outputs_with(collection_of_outputs:, dynamic_options:)
+        build_all_attributes(
+          inputs: collection_of_inputs,
+          internals: collection_of_internals,
+          outputs: collection_of_outputs,
+          dynamic_options: extract_dynamic_options_from(config)
+        )
 
         self
       end
 
       private
 
-      def build_inputs_with(collection_of_inputs:, dynamic_options:)
-        @inputs = collection_of_inputs.to_h do |input|
-          options = build_options_for(input, dynamic_options)
-          options = enrich_options_for(input, options)
+      def extract_dynamic_options_from(config)
+        config.input_option_helpers.dynamic_options
+      end
 
-          options[:required] = input.required
-          options[:default] = input.default
+      def build_all_attributes(inputs:, internals:, outputs:, dynamic_options:)
+        build_input_attributes_with(collection: inputs, dynamic_options:)
+        build_internal_attributes_with(collection: internals, dynamic_options:)
+        build_output_attributes_with(collection: outputs, dynamic_options:)
+      end
 
-          [
-            input.name,
-            options
-          ]
-        end
+      def build_input_attributes_with(collection:, dynamic_options:)
+        @inputs = build_attributes_with(
+          collection:,
+          dynamic_options:,
+          include_specific_options: true
+        )
       end
 
-      def build_internals_with(collection_of_internals:, dynamic_options:)
-        @internals = collection_of_internals.to_h do |internal|
-          options = build_options_for(internal, dynamic_options)
-          options = enrich_options_for(internal, options)
+      def build_internal_attributes_with(collection:, dynamic_options:)
+        @internals = build_attributes_with(
+          collection:,
+          dynamic_options:
+        )
+      end
 
-          [
-            internal.name,
-            options
-          ]
-        end
+      def build_output_attributes_with(collection:, dynamic_options:)
+        @outputs = build_attributes_with(
+          collection:,
+          dynamic_options:
+        )
       end
 
-      def build_outputs_with(collection_of_outputs:, dynamic_options:)
-        @outputs = collection_of_outputs.to_h do |output|
-          options = build_options_for(output, dynamic_options)
-          options = enrich_options_for(output, options)
+      def build_attributes_with(collection:, dynamic_options:, include_specific_options: false) # rubocop:disable Metrics/MethodLength
+        collection.to_h do |attribute|
+          options = process_options_for(
+            attribute:,
+            dynamic_options:
+          )
+
+          if include_specific_options
+            options[:required] = attribute.required
+            options[:default] = attribute.default
+          end
 
-          [
-            output.name,
-            options
-          ]
+          [attribute.name, options]
         end
       end
 
-      ##########################################################################
+      def process_options_for(attribute:, dynamic_options:)
+        options = build_dynamic_options_for(
+          attribute:,
+          dynamic_options:
+        )
 
-      def build_options_for(attribute, dynamic_options)
+        enrich_options_with_common_fields(
+          attribute:,
+          options:
+        )
+      end
+
+      def build_dynamic_options_for(attribute:, dynamic_options:)
         attribute.options.to_h do |key, value|
           dynamic_option = dynamic_options.find_by(name: key)
-
           next [nil, nil] if dynamic_option.nil?
 
           body_key = dynamic_option.meta.fetch(:body_key)
+          option = format_option_value(body_key:, value:)
 
-          option = build_option_from(body_key:, value:)
-
-          [
-            dynamic_option.name,
-            option
-          ]
+          [dynamic_option.name, option]
         end.compact
       end
 
-      def build_option_from(body_key:, value:)
+      def format_option_value(body_key:, value:)
         {
-          body_key => value.is_a?(Hash) ? value.fetch(body_key, value) : value,
-          message: value.is_a?(Hash) ? value.fetch(:message, nil) : nil
+          body_key => extract_value_for_body_key(body_key:, value:),
+          message: extract_message_from_value(value:)
         }
       end
 
-      def enrich_options_for(attribute, options)
+      def extract_value_for_body_key(body_key:, value:)
+        value.is_a?(Hash) ? value.fetch(body_key, value) : value
+      end
+
+      def extract_message_from_value(value:)
+        value.is_a?(Hash) ? value.fetch(:message, nil) : nil
+      end
+
+      def enrich_options_with_common_fields(attribute:, options:)
         actor = attribute.class::Actor.new(attribute)
         must = attribute.collection_of_options.find_by(name: :must)
 
         options.merge(
           actor:,
           types: attribute.types,
-          must: must.body
+          must: must&.body
         )
       end
     end

data/lib/servactory/inputs/input.rb

@@ -2,7 +2,7 @@
 
 module Servactory
   module Inputs
-    class Input
+    class Input # rubocop:disable Metrics/ClassLength
       class Actor
         attr_reader :name,
                     :internal_name,
@@ -10,21 +10,33 @@ module Servactory
                     :default,
                     :options
 
-        def initialize(input) # rubocop:disable Metrics/MethodLength
+        def initialize(input)
           @name = input.name
           @internal_name = input.internal_name
           @types = input.types
           @default = input.default
           @options = input.options
 
-          define_singleton_method(:system_name) { input.system_name }
-          define_singleton_method(:i18n_name) { input.i18n_name }
-          define_singleton_method(:optional?) { input.optional? }
-          define_singleton_method(:required?) { input.required? }
-          # The methods below are required to support the internal work.
-          define_singleton_method(:input?) { true }
-          define_singleton_method(:internal?) { false }
-          define_singleton_method(:output?) { false }
+          define_identity_methods(input)
+        end
+
+        private
+
+        def define_identity_methods(input) # rubocop:disable Metrics/MethodLength
+          methods_map = {
+            system_name: -> { input.system_name },
+            i18n_name: -> { input.i18n_name },
+            optional?: -> { input.optional? },
+            required?: -> { input.required? },
+            # The methods below are required to support the internal work.
+            input?: -> { true },
+            internal?: -> { false },
+            output?: -> { false }
+          }
+
+          methods_map.each do |method_name, implementation|
+            define_singleton_method(method_name, &implementation)
+          end
         end
       end
 
@@ -51,7 +63,6 @@ module Servactory
 
       def method_missing(name, *args, &block)
         option = @collection_of_options.find_by(name:)
-
         return super if option.nil?
 
         option.body
@@ -61,49 +72,14 @@ module Servactory
         @collection_of_options.names.include?(name) || super
       end
 
-      def register_options(helpers:, options:) # rubocop:disable Metrics/MethodLength
-        advanced_helpers = options.except(*Servactory::Maintenance::Attributes::Options::Registrar::RESERVED_OPTIONS)
-
-        options = apply_helpers_for_options(helpers:, options:) if helpers.present?
-        options = apply_helpers_for_options(helpers: advanced_helpers, options:) if advanced_helpers.present?
-
-        options_registrar = Servactory::Maintenance::Attributes::Options::Registrar.register(
-          attribute: self,
-          options:,
-          features: {
-            required: true,
-            types: true,
-            default: true,
-            must: true,
-            prepare: true
-          }
-        )
+      def register_options(helpers:, options:)
+        merged_options = augment_options_with_helpers(helpers:, options:)
+        options_registrar = create_options_registrar(options: merged_options)
 
-        @options = options
+        @options = merged_options
         @collection_of_options = options_registrar.collection
       end
 
-      def apply_helpers_for_options(helpers:, options:) # rubocop:disable Metrics/MethodLength
-        prepared_options = {}
-
-        helpers.each do |(helper, values)|
-          found_helper = @option_helpers.find_by(name: helper)
-
-          next if found_helper.blank?
-
-          prepared_option =
-            if found_helper.equivalent.is_a?(Proc)
-              values.is_a?(Hash) ? found_helper.equivalent.call(**values) : found_helper.equivalent.call(values)
-            else
-              found_helper.equivalent
-            end
-
-          prepared_options.deep_merge!(prepared_option)
-        end
-
-        options.deep_merge(prepared_options)
-      end
-
       def options_for_checks
         @collection_of_options.options_for_checks
       end
@@ -135,6 +111,71 @@ module Servactory
       def output?
         false
       end
+
+      private
+
+      def create_options_registrar(options:)
+        Servactory::Maintenance::Attributes::Options::Registrar.register(
+          attribute: self,
+          options:,
+          features: available_feature_options
+        )
+      end
+
+      def available_feature_options
+        {
+          required: true,
+          types: true,
+          default: true,
+          must: true,
+          prepare: true
+        }
+      end
+
+      def augment_options_with_helpers(helpers:, options:)
+        result_options = options.dup
+        merge_standard_helpers_into(target_options: result_options, helpers:) if helpers.present?
+        merge_advanced_helpers_into(target_options: result_options, source_options: options)
+        result_options
+      end
+
+      def merge_standard_helpers_into(target_options:, helpers:)
+        standard_helpers_result = transform_helpers_to_options(helpers:)
+        target_options.deep_merge!(standard_helpers_result)
+      end
+
+      def merge_advanced_helpers_into(target_options:, source_options:)
+        advanced_helpers = filter_advanced_helpers(options: source_options)
+        return if advanced_helpers.blank?
+
+        advanced_helpers_result = transform_helpers_to_options(helpers: advanced_helpers)
+        target_options.deep_merge!(advanced_helpers_result)
+      end
+
+      def filter_advanced_helpers(options:)
+        reserved_options = Servactory::Maintenance::Attributes::Options::Registrar::RESERVED_OPTIONS
+        options.except(*reserved_options)
+      end
+
+      def transform_helpers_to_options(helpers:)
+        helpers.each_with_object({}) do |(helper_name, values), result|
+          helper = @option_helpers.find_by(name: helper_name)
+          next if helper.blank?
+
+          transformed_option = transform_helper_to_option(helper:, values:)
+          result.deep_merge!(transformed_option) if transformed_option.present?
+        end
+      end
+
+      def transform_helper_to_option(helper:, values:)
+        return helper.equivalent unless helper.equivalent.is_a?(Proc)
+
+        if values.is_a?(Hash)
+          helper.equivalent.call(**values)
+        else
+          helper.equivalent.call(values)
+        end
+      end
     end
   end
 end

data/lib/servactory/inputs/tools/validation.rb

@@ -36,9 +36,11 @@ module Servactory
               input:,
               check_key:,
               check_options:
-            )
+            ).to_a
 
-            errors.merge(errors_from_checks.to_a)
+            next if errors_from_checks.empty?
+
+            errors.merge(errors_from_checks)
           end
         end
 

data/lib/servactory/internals/internal.rb

@@ -13,12 +13,24 @@ module Servactory
           @types = internal.types
           @options = internal.options
 
-          define_singleton_method(:system_name) { internal.system_name }
-          define_singleton_method(:i18n_name) { internal.i18n_name }
-          # The methods below are required to support the internal work.
-          define_singleton_method(:input?) { false }
-          define_singleton_method(:internal?) { true }
-          define_singleton_method(:output?) { false }
+          define_identity_methods(internal)
+        end
+
+        private
+
+        def define_identity_methods(internal)
+          methods_map = {
+            system_name: -> { internal.system_name },
+            i18n_name: -> { internal.i18n_name },
+            # The methods below are required to support the internal work.
+            input?: -> { false },
+            internal?: -> { true },
+            output?: -> { false }
+          }
+
+          methods_map.each do |method_name, implementation|
+            define_singleton_method(method_name, &implementation)
+          end
         end
       end
 
@@ -40,7 +52,6 @@ module Servactory
 
       def method_missing(name, *args, &block)
         option = @collection_of_options.find_by(name:)
-
         return super if option.nil?
 
         option.body
@@ -50,46 +61,14 @@ module Servactory
         @collection_of_options.names.include?(name) || super
       end
 
-      def register_options(helpers:, options:) # rubocop:disable Metrics/MethodLength
-        advanced_helpers = options.except(*Servactory::Maintenance::Attributes::Options::Registrar::RESERVED_OPTIONS)
-
-        options = apply_helpers_for_options(helpers:, options:) if helpers.present?
-        options = apply_helpers_for_options(helpers: advanced_helpers, options:) if advanced_helpers.present?
-
-        options_registrar = Servactory::Maintenance::Attributes::Options::Registrar.register(
-          attribute: self,
-          options:,
-          features: {
-            types: true,
-            must: true
-          }
-        )
+      def register_options(helpers:, options:)
+        merged_options = augment_options_with_helpers(helpers:, options:)
+        options_registrar = create_options_registrar(options: merged_options)
 
-        @options = options
+        @options = merged_options
         @collection_of_options = options_registrar.collection
       end
 
-      def apply_helpers_for_options(helpers:, options:) # rubocop:disable Metrics/MethodLength
-        prepared_options = {}
-
-        helpers.each do |(helper, values)|
-          found_helper = @option_helpers.find_by(name: helper)
-
-          next if found_helper.blank?
-
-          prepared_option =
-            if found_helper.equivalent.is_a?(Proc)
-              values.is_a?(Hash) ? found_helper.equivalent.call(**values) : found_helper.equivalent.call(values)
-            else
-              found_helper.equivalent
-            end
-
-          prepared_options.deep_merge!(prepared_option)
-        end
-
-        options.deep_merge(prepared_options)
-      end
-
       def options_for_checks
         @collection_of_options.options_for_checks
       end
@@ -113,6 +92,68 @@ module Servactory
       def output?
         false
       end
+
+      private
+
+      def create_options_registrar(options:)
+        Servactory::Maintenance::Attributes::Options::Registrar.register(
+          attribute: self,
+          options:,
+          features: available_feature_options
+        )
+      end
+
+      def available_feature_options
+        {
+          types: true,
+          must: true
+        }
+      end
+
+      def augment_options_with_helpers(helpers:, options:)
+        result_options = options.dup
+        merge_standard_helpers_into(target_options: result_options, helpers:) if helpers.present?
+        merge_advanced_helpers_into(target_options: result_options, source_options: options)
+        result_options
+      end
+
+      def merge_standard_helpers_into(target_options:, helpers:)
+        standard_helpers_result = transform_helpers_to_options(helpers:)
+        target_options.deep_merge!(standard_helpers_result)
+      end
+
+      def merge_advanced_helpers_into(target_options:, source_options:)
+        advanced_helpers = filter_advanced_helpers(options: source_options)
+        return if advanced_helpers.blank?
+
+        advanced_helpers_result = transform_helpers_to_options(helpers: advanced_helpers)
+        target_options.deep_merge!(advanced_helpers_result)
+      end
+
+      def filter_advanced_helpers(options:)
+        reserved_options = Servactory::Maintenance::Attributes::Options::Registrar::RESERVED_OPTIONS
+        options.except(*reserved_options)
+      end
+
+      def transform_helpers_to_options(helpers:)
+        helpers.each_with_object({}) do |(helper_name, values), result|
+          helper = @option_helpers.find_by(name: helper_name)
+          next if helper.blank?
+
+          transformed_option = transform_helper_to_option(helper:, values:)
+          result.deep_merge!(transformed_option) if transformed_option.present?
+        end
+      end
+
+      def transform_helper_to_option(helper:, values:)
+        return helper.equivalent unless helper.equivalent.is_a?(Proc)
+
+        if values.is_a?(Hash)
+          helper.equivalent.call(**values)
+        else
+          helper.equivalent.call(values)
+        end
+      end
     end
   end
 end