servactory 3.0.0 → 3.1.0.rc2

data/lib/servactory/outputs/output.rb

@@ -2,7 +2,7 @@
 
 module Servactory
   module Outputs
-    class Output
+    class Output < Servactory::Maintenance::Attributes::Base
       class Actor
         attr_reader :name,
                     :types,
@@ -26,138 +26,30 @@ module Servactory
         # The methods below are required to support the internal work.
 
         def input?
-          false
+          @attribute.input?
         end
 
         def internal?
-          false
+          @attribute.internal?
         end
 
         def output?
-          true
+          @attribute.output?
         end
       end
 
-      attr_reader :name,
-                  :collection_of_options,
-                  :options
-
-      def initialize(
-        name,
-        *helpers,
-        option_helpers:,
-        **options
-      )
-        @name = name
-        @option_helpers = option_helpers
-
-        register_options(helpers:, options:)
-      end
-
-      def method_missing(name, *args, &block)
-        option = @collection_of_options.find_by(name:)
-        return super if option.nil?
-
-        option.body
-      end
-
-      def respond_to_missing?(name, *)
-        @collection_of_options.names.include?(name) || super
-      end
-
-      def register_options(helpers:, options:)
-        merged_options = augment_options_with_helpers(helpers:, options:)
-        options_registrar = create_options_registrar(options: merged_options)
-
-        @options = merged_options
-        @collection_of_options = options_registrar.collection
-      end
-
-      def options_for_checks
-        @collection_of_options.options_for_checks
-      end
-
-      def system_name
-        self.class.name.demodulize.downcase.to_sym
-      end
-
-      def i18n_name
-        system_name.to_s.pluralize
-      end
-
-      def input?
-        false
-      end
-
-      def internal?
-        false
-      end
-
       def output?
         true
       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

data/lib/servactory/result.rb

@@ -44,7 +44,7 @@ module Servactory
   class Result
     # Internal container for service output values.
     #
-    # Provides dynamic method access to output values via method_missing.
+    # Provides dynamic method access to output values.
     # Stores outputs in hash and supports predicate methods when enabled.
     class Outputs
       # Creates an Outputs container with given output values.
@@ -65,13 +65,6 @@ module Servactory
       end
 
       # Delegates method calls to stored outputs.
-      #
-      # Supports both regular output access and predicate methods
-      # when predicate_methods_enabled is true.
-      #
-      # @param name [Symbol] Method name (output or predicate)
-      # @param args [Array] Method arguments
-      # @return [Object] Output value or predicate result
       def method_missing(name, *args)
         if name.to_s.end_with?("?")
           base_name = name.to_s.chomp("?").to_sym
@@ -86,10 +79,6 @@ module Servactory
       end
 
       # Checks if method corresponds to stored output.
-      #
-      # @param name [Symbol] Method name to check
-      # @param include_private [Boolean] Include private methods in check
-      # @return [Boolean] True if output exists for this method
       def respond_to_missing?(name, include_private = false)
         if name.to_s.end_with?("?")
           base_name = name.to_s.chomp("?").to_sym
@@ -297,15 +286,13 @@ module Servactory
       self
     end
 
-    # Delegates method calls to outputs container.
-    #
-    # Provides access to output attributes as if they were
-    # defined on the Result instance itself.
+    # Delegates method calls to the outputs container.
     #
     # @param name [Symbol] Method name (output attribute)
     # @param args [Array] Method arguments
     # @param block [Proc] Optional block
-    # @return [Object] Output value
+    # @return [Object] Output value when name matches an output attribute
+    # @raise [NoMethodError] When method is truly undefined and no context present
     def method_missing(name, *args, &block)
       return outputs.public_send(name, *args, &block) if outputs.respond_to?(name)
 
@@ -350,7 +337,14 @@ module Servactory
     #
     # @return [Outputs] Outputs container with service values
     def outputs
-      @outputs ||= Outputs.new(
+      @outputs ||= build_outputs
+    end
+
+    # Builds Outputs container with predicate configuration.
+    #
+    # @return [Outputs] New outputs container
+    def build_outputs
+      Outputs.new(
         outputs: build_outputs_hash,
         predicate_methods_enabled:
           @context.is_a?(Servactory::TestKit::Result) || @context.config.predicate_methods_enabled

data/lib/servactory/tool_kit/dynamic_options/must.rb

@@ -155,9 +155,9 @@ module Servactory
         # Creates an OptionHelper for registration with Servactory.
         #
         # @param name [Symbol] Internal validation name
-        # @return [Servactory::Maintenance::Attributes::OptionHelper]
+        # @return [Servactory::Maintenance::Options::Helper]
         def must(name)
-          Servactory::Maintenance::Attributes::OptionHelper.new(
+          Servactory::Maintenance::Options::Helper.new(
             name: @option_name,
             equivalent: equivalent_with(name),
             meta: {

data/lib/servactory/tool_kit/dynamic_options/schema.rb

@@ -277,7 +277,7 @@ module Servactory
             return true
           end
 
-          value = object.fetch(schema_key, nil)
+          value = object[schema_key]
           prepared_value = prepare_value_from(schema_value:, value:, required: attribute_required)
 
           [
@@ -297,7 +297,7 @@ module Servactory
           required || (
             !required && !fetch_default_from(schema_value).nil?
           ) || (
-            !required && !object.fetch(schema_key, nil).nil?
+            !required && !object[schema_key].nil?
           )
         end
 
@@ -320,7 +320,7 @@ module Servactory
         # @param value [Hash] Schema definition
         # @return [Object, nil] Default value or nil
         def fetch_default_from(value)
-          value.fetch(:default, nil)
+          value[:default]
         end
 
         ########################################################################
@@ -352,14 +352,14 @@ module Servactory
               )
             else
               # Apply scalar defaults.
-              default_value = schema_value.fetch(:default, nil)
+              default_value = schema_value[:default]
 
               if !required && !default_value.nil? && !Servactory::Utils.value_present?(object_value)
                 object[schema_key] = default_value
               end
 
               # Execute prepare callback if defined.
-              unless (input_prepare = schema_value.fetch(:prepare, nil)).nil?
+              unless (input_prepare = schema_value[:prepare]).nil?
                 object[schema_key] = input_prepare.call(value: object[schema_key])
               end
 

data/lib/servactory/utils.rb

@@ -12,14 +12,6 @@ module Servactory
       data.symbolize_keys
     end
 
-    def fetch_hash_with_desired_attribute(attribute)
-      return { input: attribute.class::Actor.new(attribute) } if really_input?(attribute)
-      return { internal: attribute.class::Actor.new(attribute) } if really_internal?(attribute)
-      return { output: attribute.class::Actor.new(attribute) } if really_output?(attribute)
-
-      raise ArgumentError, "Failed to define attribute"
-    end
-
     def define_attribute_with(input: nil, internal: nil, output: nil)
       return input if really_input?(input)
       return internal if really_internal?(internal)

data/lib/servactory/version.rb

@@ -3,9 +3,9 @@
 module Servactory
   module VERSION
     MAJOR = 3
-    MINOR = 0
+    MINOR = 1
     PATCH = 0
-    PRE = nil
+    PRE = "rc2"
 
     STRING = [MAJOR, MINOR, PATCH, PRE].compact.join(".")
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: servactory
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 3.1.0.rc2
 platform: ruby
 authors:
 - Anton Sokolov
@@ -264,19 +264,22 @@ files:
 - lib/servactory/internals/collection.rb
 - lib/servactory/internals/dsl.rb
 - lib/servactory/internals/internal.rb
-- lib/servactory/maintenance/attributes/define_conflict.rb
-- lib/servactory/maintenance/attributes/define_method.rb
-- lib/servactory/maintenance/attributes/option.rb
+- lib/servactory/maintenance/attributes/base.rb
+- lib/servactory/maintenance/attributes/collection.rb
 - lib/servactory/maintenance/attributes/option_helper.rb
-- lib/servactory/maintenance/attributes/options/registrar.rb
-- lib/servactory/maintenance/attributes/options_collection.rb
-- lib/servactory/maintenance/attributes/tools/validation.rb
-- lib/servactory/maintenance/attributes/translator/must.rb
-- lib/servactory/maintenance/attributes/translator/type.rb
-- lib/servactory/maintenance/attributes/validations/concerns/error_builder.rb
-- lib/servactory/maintenance/attributes/validations/must.rb
-- lib/servactory/maintenance/attributes/validations/type.rb
-- lib/servactory/maintenance/validations/types.rb
+- lib/servactory/maintenance/options/collection.rb
+- lib/servactory/maintenance/options/define_conflict.rb
+- lib/servactory/maintenance/options/define_method.rb
+- lib/servactory/maintenance/options/helper.rb
+- lib/servactory/maintenance/options/option.rb
+- lib/servactory/maintenance/options/registrar.rb
+- lib/servactory/maintenance/validations/checkers/must.rb
+- lib/servactory/maintenance/validations/checkers/type.rb
+- lib/servactory/maintenance/validations/concerns/error_builder.rb
+- lib/servactory/maintenance/validations/performer.rb
+- lib/servactory/maintenance/validations/support/type_validator.rb
+- lib/servactory/maintenance/validations/translator/must.rb
+- lib/servactory/maintenance/validations/translator/type.rb
 - lib/servactory/outputs/collection.rb
 - lib/servactory/outputs/dsl.rb
 - lib/servactory/outputs/output.rb

data/lib/servactory/maintenance/attributes/options/registrar.rb

@@ -1,183 +0,0 @@
-# frozen_string_literal: true
-
-module Servactory
-  module Maintenance
-    module Attributes
-      module Options
-        class Registrar # rubocop:disable Metrics/ClassLength
-          RESERVED_OPTIONS = %i[
-            type
-            required
-            default
-            collection
-            must
-            prepare
-          ].freeze
-
-          DEFAULT_FEATURES = {
-            required: false,
-            types: false,
-            default: false,
-            must: false,
-            prepare: false
-          }.freeze
-
-          private_constant :DEFAULT_FEATURES
-
-          def self.register(...)
-            new(...).register
-          end
-
-          def initialize(attribute:, options:, features:)
-            @attribute = attribute
-            @options = options
-            @features = DEFAULT_FEATURES.merge(features)
-          end
-
-          ########################################################################
-
-          def register
-            register_feature(:required, Servactory::Inputs::Validations::Required)
-            register_feature(:types, Servactory::Maintenance::Attributes::Validations::Type)
-            register_feature(:default, Servactory::Maintenance::Attributes::Validations::Type)
-            register_feature(:must, Servactory::Maintenance::Attributes::Validations::Must)
-            register_feature(:prepare, nil)
-
-            self
-          end
-
-          def collection
-            @collection ||= Servactory::Maintenance::Attributes::OptionsCollection.new
-          end
-
-          private
-
-          def register_feature(feature_name, validation_class)
-            return unless @features.fetch(feature_name)
-
-            method_name = "register_#{feature_name}_option"
-            send(method_name, validation_class)
-          end
-
-          ########################################################################
-
-          def register_required_option(validation_class)
-            create_option(
-              name: :required,
-              validation_class:,
-              define_methods: required_define_methods,
-              define_conflicts: required_define_conflicts,
-              need_for_checks: true,
-              body_key: :is,
-              body_fallback: true
-            )
-          end
-
-          def register_types_option(validation_class)
-            create_option(
-              name: :types,
-              validation_class:,
-              original_value: Array(@options.fetch(:type)).uniq,
-              need_for_checks: true,
-              body_key: :is,
-              body_fallback: nil,
-              with_advanced_mode: false
-            )
-          end
-
-          def register_default_option(validation_class) # rubocop:disable Metrics/MethodLength
-            create_option(
-              name: :default,
-              validation_class:,
-              define_methods: [
-                create_define_method(
-                  name: :default_value_present?,
-                  content: ->(option:) { !option.nil? }
-                )
-              ],
-              need_for_checks: true,
-              body_key: :is,
-              body_fallback: nil,
-              with_advanced_mode: false
-            )
-          end
-
-          def register_must_option(validation_class) # rubocop:disable Metrics/MethodLength
-            create_option(
-              name: :must,
-              validation_class:,
-              define_methods: [
-                create_define_method(
-                  name: :must_present?,
-                  content: ->(option:) { option.present? }
-                )
-              ],
-              need_for_checks: true,
-              body_key: :is,
-              body_fallback: nil,
-              with_advanced_mode: false
-            )
-          end
-
-          def register_prepare_option(_validation_class) # rubocop:disable Metrics/MethodLength
-            create_option(
-              name: :prepare,
-              validation_class: nil,
-              define_methods: [
-                create_define_method(
-                  name: :prepare_present?,
-                  content: ->(option:) { option[:in].present? }
-                )
-              ],
-              need_for_checks: false,
-              body_key: :in,
-              body_fallback: false
-            )
-          end
-
-          ########################################################################
-
-          def required_define_methods
-            [
-              create_define_method(
-                name: :required?,
-                content: ->(option:) { Servactory::Utils.true?(option[:is]) }
-              ),
-              create_define_method(
-                name: :optional?,
-                content: ->(option:) { !Servactory::Utils.true?(option[:is]) }
-              )
-            ]
-          end
-
-          def required_define_conflicts
-            [
-              Servactory::Maintenance::Attributes::DefineConflict.new(
-                content: -> { :required_vs_default if @attribute.required? && @attribute.default_value_present? }
-              )
-            ]
-          end
-
-          ########################################################################
-
-          def create_option(name:, validation_class:, **options)
-            collection << Servactory::Maintenance::Attributes::Option.new(
-              name:,
-              attribute: @attribute,
-              validation_class:,
-              **options,
-              **@options
-            )
-          end
-
-          def create_define_method(name:, content:)
-            Servactory::Maintenance::Attributes::DefineMethod.new(
-              name:,
-              content:
-            )
-          end
-        end
-      end
-    end
-  end
-end

data/lib/servactory/maintenance/attributes/tools/validation.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-module Servactory
-  module Maintenance
-    module Attributes
-      module Tools
-        class Validation
-          def self.validate!(...)
-            new(...).validate!
-          end
-
-          def initialize(context:, attribute:, value:)
-            @context = context
-            @attribute = attribute
-            @value = value
-            @first_error = nil
-          end
-
-          def validate!
-            process
-
-            raise_errors
-          end
-
-          private
-
-          def process
-            @attribute.options_for_checks.each do |check_key, check_options|
-              process_option(check_key, check_options)
-              break if @first_error.present?
-            end
-          end
-
-          def process_option(check_key, check_options) # rubocop:disable Metrics/MethodLength
-            return if validation_classes.empty?
-
-            validation_classes.each do |validation_class|
-              error_message = process_validation_class(
-                validation_class:,
-                check_key:,
-                check_options:
-              )
-
-              next if error_message.blank?
-
-              @first_error = error_message
-              break
-            end
-          end
-
-          def process_validation_class(
-            validation_class:,
-            check_key:,
-            check_options:
-          )
-            validation_class.check(
-              context: @context,
-              attribute: @attribute,
-              value: @value,
-              check_key:,
-              check_options:
-            )
-          end
-
-          ########################################################################
-
-          def validation_classes
-            @validation_classes ||= @attribute.collection_of_options.validation_classes
-          end
-
-          ########################################################################
-
-          def raise_errors
-            return if @first_error.nil?
-
-            raise @context.config
-                          .public_send(:"#{@attribute.system_name}_exception_class")
-                          .new(context: @context, message: @first_error)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/servactory/maintenance/attributes/validations/concerns/error_builder.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module Servactory
-  module Maintenance
-    module Attributes
-      module Validations
-        module Concerns
-          # Concern providing error message processing for validators.
-          #
-          # ## Purpose
-          #
-          # ErrorBuilder provides shared logic for processing error messages that
-          # can be either static strings or dynamic Procs. This allows validators
-          # to support both simple error messages and context-aware messages.
-          #
-          # ## Usage
-          #
-          # Extend in validator classes:
-          #
-          # ```ruby
-          # class MyValidator
-          #   extend Concerns::ErrorBuilder
-          #
-          #   def self.build_error(...)
-          #     process_message(message, **context)
-          #   end
-          # end
-          # ```
-          #
-          # ## Methods Provided
-          #
-          # - `process_message` - converts String or Proc message to String
-          module ErrorBuilder
-            # Processes a message that may be a String or Proc.
-            #
-            # If message is a Proc, calls it with the provided attributes.
-            # If message is a String, returns it unchanged.
-            #
-            # @param message [String, Proc] The message to process
-            # @param attributes [Hash] Attributes to pass to Proc if message is callable
-            # @return [String] The processed message string
-            def process_message(message, **attributes)
-              return message unless message.is_a?(Proc)
-
-              message.call(**attributes)
-            end
-          end
-        end
-      end
-    end
-  end
-end