servactory 1.9.6 → 2.0.0.rc3

data/lib/servactory/maintenance/attributes/define_conflict.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Maintenance
+    module Attributes
+      class DefineConflict
+        attr_reader :content
+
+        def initialize(content:)
+          @content = content
+        end
+      end
+    end
+  end
+end

data/lib/servactory/maintenance/attributes/define_method.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Maintenance
+    module Attributes
+      class DefineMethod
+        attr_reader :name,
+                    :content
+
+        def initialize(name:, content:)
+          @name = name.to_sym
+          @content = content
+        end
+      end
+    end
+  end
+end

data/lib/servactory/maintenance/attributes/option.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Maintenance
+    module Attributes
+      class Option
+        DEFAULT_BODY = ->(key:, body:, message: nil) { { key => body, message: message } }
+
+        private_constant :DEFAULT_BODY
+
+        attr_reader :name,
+                    :validation_class,
+                    :define_methods,
+                    :define_conflicts,
+                    :need_for_checks,
+                    :body
+
+        # rubocop:disable Metrics/MethodLength
+        def initialize(
+          name:,
+          attribute:,
+          validation_class:,
+          need_for_checks:,
+          body_fallback:,
+          original_value: nil,
+          body_key: nil,
+          body_value: true,
+          define_methods: nil,
+          define_conflicts: nil,
+          with_advanced_mode: true,
+          **options
+        ) # do
+          @name = name.to_sym
+          @validation_class = validation_class
+          @define_methods = define_methods
+          @define_conflicts = define_conflicts
+          @need_for_checks = need_for_checks
+
+          @body = prepare_value_for(
+            original_value: original_value,
+            options: options,
+            body_key: body_key,
+            body_value: body_value,
+            body_fallback: body_fallback,
+            with_advanced_mode: with_advanced_mode
+          )
+
+          prepare_methods_for(attribute)
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        def need_for_checks?
+          need_for_checks
+        end
+
+        private
+
+        def prepare_value_for(
+          original_value:,
+          options:,
+          body_key:,
+          body_value:,
+          body_fallback:,
+          with_advanced_mode:
+        )
+          return original_value if original_value.present?
+
+          return options.fetch(@name, body_fallback) unless with_advanced_mode
+
+          prepare_advanced_for(
+            body: options.fetch(@name, DEFAULT_BODY.call(key: body_key, body: body_fallback)),
+            body_key: body_key,
+            body_value: body_value,
+            body_fallback: body_fallback
+          )
+        end
+
+        def prepare_advanced_for(
+          body:,
+          body_key:,
+          body_value:,
+          body_fallback:
+        )
+          if body.is_a?(Hash)
+            message = body.fetch(:message, nil)
+
+            DEFAULT_BODY.call(
+              key: body_key,
+              body: body.fetch(body_key, message.present? ? body_value : body_fallback),
+              message: message
+            )
+          else
+            DEFAULT_BODY.call(key: body_key, body: body)
+          end
+        end
+
+        def prepare_methods_for(attribute)
+          attribute.instance_eval(define_methods_template) if define_methods_template.present?
+        end
+
+        def define_methods_template
+          return if @define_methods.blank?
+
+          @define_methods_template ||= @define_methods.map do |define_method|
+            <<-RUBY
+              def #{define_method.name}
+                #{define_method.content.call(option: @body)}
+              end
+            RUBY
+          end.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/servactory/maintenance/attributes/option_helper.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Maintenance
+    module Attributes
+      class OptionHelper
+        attr_reader :name,
+                    :equivalent
+
+        def initialize(name:, equivalent:)
+          @name = name
+          @equivalent = equivalent
+        end
+      end
+    end
+  end
+end

data/lib/servactory/maintenance/attributes/option_helpers_collection.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Maintenance
+    module Attributes
+      class OptionHelpersCollection
+        extend Forwardable
+        def_delegators :@collection, :<<, :find, :merge
+
+        def initialize(collection)
+          @collection = collection
+        end
+
+        def find_by(name:)
+          find { |helper| helper.name == name }
+        end
+      end
+    end
+  end
+end

data/lib/servactory/maintenance/attributes/options_collection.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Maintenance
+    module Attributes
+      class OptionsCollection
+        extend Forwardable
+        def_delegators :@collection, :<<, :filter, :each, :map, :flat_map, :find
+
+        def initialize(*)
+          @collection = Set.new
+        end
+
+        def names
+          map(&:name)
+        end
+
+        def validation_classes
+          filter { |option| option.validation_class.present? }.map(&:validation_class).uniq
+        end
+
+        def options_for_checks
+          filter(&:need_for_checks?).to_h do |option|
+            option_body = if option.body.is_a?(Hash)
+                            option.body.key?(:is) ? option.body.fetch(:is) : option.body
+                          else
+                            option.body
+                          end
+
+            [option.name, option_body]
+          end
+        end
+
+        def defined_conflict_code
+          flat_map do |option|
+            option.define_conflicts&.map do |define_input_conflict|
+              define_input_conflict.content.call
+            end
+          end.reject(&:blank?).first
+        end
+
+        def find_by(name:)
+          find { |option| option.name == name }
+        end
+      end
+    end
+  end
+end

data/lib/servactory/maintenance/collection_mode/class_names_collection.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Maintenance
+    module CollectionMode
+      class ClassNamesCollection
+        extend Forwardable
+        def_delegators :@collection, :include?
+
+        def initialize(collection)
+          @collection = collection
+        end
+      end
+    end
+  end
+end

data/lib/servactory/maintenance/hash_mode/class_names_collection.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Maintenance
+    module HashMode
+      class ClassNamesCollection
+        extend Forwardable
+        def_delegators :@collection, :include?
+
+        def initialize(collection)
+          @collection = collection
+        end
+      end
+    end
+  end
+end

data/lib/servactory/maintenance/validations/collection.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Maintenance
+    module Validations
+      class Collection
+        attr_reader :errors
+
+        def self.validate(...)
+          new(...).validate
+        end
+
+        def initialize(value:, types:, type:)
+          @value = value
+          @types = types
+          @type = type
+
+          @errors = []
+        end
+
+        def validate
+          unless @value.is_a?(prepared_type)
+            add_error(
+              expected_type: prepared_type.name,
+              given_type: @value.class.name
+            )
+
+            return self
+          end
+
+          validate_value!
+
+          self
+        end
+
+        def valid?
+          @errors.empty?
+        end
+
+        private
+
+        def prepared_type
+          @prepared_type ||= @types.fetch(0, Array)
+        end
+
+        def validate_value!
+          @value.each do |value_item|
+            next if value_item.is_a?(@type)
+
+            add_error(
+              expected_type: @type,
+              given_type: value_item.class.name
+            )
+          end
+        end
+
+        def add_error(expected_type:, given_type:)
+          @errors << {
+            expected_type: expected_type,
+            given_type: given_type
+          }
+        end
+      end
+    end
+  end
+end

data/lib/servactory/maintenance/validations/object_schema.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Maintenance
+    module Validations
+      class ObjectSchema
+        RESERVED_ATTRIBUTES = %i[type required default].freeze
+        private_constant :RESERVED_ATTRIBUTES
+
+        attr_reader :errors
+
+        def self.validate(...)
+          new(...).validate
+        end
+
+        def initialize(object:, schema:)
+          @object = object
+          @schema = schema
+
+          @errors = []
+        end
+
+        def validate
+          validate_for(object: @object, schema: @schema)
+
+          self
+        end
+
+        def valid?
+          @errors.empty?
+        end
+
+        private
+
+        def validate_for(object:, schema:, root_schema_key: nil) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+          unless object.respond_to?(:fetch)
+            add_error(key_name: root_schema_key, expected_type: Hash.name, given_type: object.class.name)
+            return
+          end
+
+          schema.each do |schema_key, schema_value|
+            attribute_type = schema_value.fetch(:type, String)
+
+            if attribute_type == Hash
+              validate_for(
+                object: object.fetch(schema_key, {}),
+                schema: schema_value.except(*RESERVED_ATTRIBUTES),
+                root_schema_key: schema_key
+              )
+            else
+              is_success = validate_with(
+                object: object,
+                schema_key: schema_key,
+                schema_value: schema_value,
+                attribute_type: attribute_type,
+                attribute_required: schema_value.fetch(:required, true)
+              )
+
+              next if is_success
+
+              add_error(
+                key_name: schema_key,
+                expected_type: attribute_type,
+                given_type: object.fetch(schema_key, nil).class.name
+              )
+            end
+          end
+        end
+
+        def validate_with(object:, schema_key:, schema_value:, attribute_type:, attribute_required:) # rubocop:disable Metrics/MethodLength
+          unless should_be_checked_for?(
+            object: object,
+            schema_key: schema_key,
+            schema_value: schema_value,
+            required: attribute_required
+          ) # do
+            return true
+          end
+
+          value = object.fetch(schema_key, nil)
+          prepared_value = prepare_value_from(schema_value: schema_value, value: value, required: attribute_required)
+
+          Array(attribute_type).any? { |type| prepared_value.is_a?(type) }
+        end
+
+        def should_be_checked_for?(object:, schema_key:, schema_value:, required:)
+          required || (
+            !required && !fetch_default_from(schema_value).nil?
+          ) || (
+            !required && !object.fetch(schema_key, nil).nil?
+          )
+        end
+
+        def prepare_value_from(schema_value:, value:, required:)
+          if !required && !fetch_default_from(schema_value).nil? && value.blank?
+            fetch_default_from(schema_value)
+          else
+            value
+          end
+        end
+
+        def fetch_default_from(value)
+          value.fetch(:default, nil)
+        end
+
+        def add_error(key_name:, expected_type:, given_type:)
+          @errors << {
+            key_name: key_name,
+            expected_type: expected_type,
+            given_type: given_type
+          }
+        end
+      end
+    end
+  end
+end

data/lib/servactory/maintenance/validations/types.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Maintenance
+    module Validations
+      class Types # rubocop:disable Metrics/ClassLength
+        DEFAULT_MESSAGE = lambda do | # rubocop:disable Metrics/BlockLength
+          service_class_name:,
+          attribute_system_name:,
+          attribute:,
+          value:,
+          key_name:,
+          expected_type:,
+          given_type:
+        | # do
+          if attribute.collection_mode?
+            collection_message = attribute.consists_of.fetch(:message)
+
+            if collection_message.is_a?(Proc)
+              collection_message.call(attribute_system_name => attribute, expected_type: expected_type)
+            elsif collection_message.is_a?(String) && collection_message.present?
+              collection_message
+            elsif value.is_a?(attribute.types.fetch(0, Array))
+              I18n.t(
+                "servactory.#{attribute_system_name.to_s.pluralize}.checks.type.default_error.for_collection.wrong_element_type", # rubocop:disable Layout/LineLength
+                service_class_name: service_class_name,
+                "#{attribute_system_name}_name": attribute.name,
+                expected_type: expected_type,
+                given_type: given_type
+              )
+            else
+              I18n.t(
+                "servactory.#{attribute_system_name.to_s.pluralize}.checks.type.default_error.for_collection.wrong_type", # rubocop:disable Layout/LineLength
+                service_class_name: service_class_name,
+                "#{attribute_system_name}_name": attribute.name,
+                expected_type: attribute.types.fetch(0, Array),
+                given_type: value.class.name
+              )
+            end
+          elsif attribute.hash_mode? && key_name.present?
+            I18n.t(
+              "servactory.#{attribute_system_name.to_s.pluralize}.checks.type.default_error.for_hash.wrong_element_type", # rubocop:disable Layout/LineLength
+              service_class_name: service_class_name,
+              "#{attribute_system_name}_name": attribute.name,
+              key_name: key_name,
+              expected_type: expected_type,
+              given_type: given_type
+            )
+          else
+            I18n.t(
+              "servactory.#{attribute_system_name.to_s.pluralize}.checks.type.default_error.default",
+              service_class_name: service_class_name,
+              "#{attribute_system_name}_name": attribute.name,
+              expected_type: expected_type,
+              given_type: given_type
+            )
+          end
+        end
+
+        private_constant :DEFAULT_MESSAGE
+
+        def self.validate!(...)
+          new(...).validate!
+        end
+
+        def initialize(context:, attribute:, types:, value:, error_callback:)
+          @context = context
+          @attribute = attribute
+          @types = types
+          @value = value
+          @error_callback = error_callback
+        end
+
+        def validate! # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          collection_validator = nil
+          object_schema_validator = nil
+
+          return if prepared_types.any? do |type|
+            if @attribute.collection_mode?
+              collection_validator = Servactory::Maintenance::Validations::Collection.validate(
+                value: @value,
+                types: @attribute.types,
+                type: type
+              )
+
+              collection_validator.valid?
+            elsif @attribute.hash_mode?
+              object_schema_validator = Servactory::Maintenance::Validations::ObjectSchema.validate(
+                object: @value,
+                schema: @attribute.schema
+              )
+
+              object_schema_validator.valid?
+            else
+              @value.is_a?(type)
+            end
+          end
+
+          if (first_error = collection_validator&.errors&.first).present?
+            return @error_callback.call(
+              message: DEFAULT_MESSAGE,
+              service_class_name: @context.class.name,
+              attribute_system_name: attribute_system_name,
+              attribute: @attribute,
+              value: @value,
+              key_name: nil,
+              expected_type: first_error.fetch(:expected_type),
+              given_type: first_error.fetch(:given_type)
+            )
+          end
+
+          if (first_error = object_schema_validator&.errors&.first).present?
+            return @error_callback.call(
+              message: DEFAULT_MESSAGE,
+              service_class_name: @context.class.name,
+              attribute_system_name: attribute_system_name,
+              attribute: @attribute,
+              value: @value,
+              key_name: first_error.fetch(:key_name),
+              expected_type: first_error.fetch(:expected_type),
+              given_type: first_error.fetch(:given_type)
+            )
+          end
+
+          @error_callback.call(
+            message: DEFAULT_MESSAGE,
+            service_class_name: @context.class.name,
+            attribute_system_name: attribute_system_name,
+            attribute: @attribute,
+            value: @value,
+            key_name: nil,
+            expected_type: prepared_types.join(", "),
+            given_type: @value.class.name
+          )
+        end
+
+        private
+
+        def attribute_system_name
+          @attribute.class.name.demodulize.downcase.to_sym
+        end
+
+        def prepared_types
+          @prepared_types ||=
+            if @attribute.collection_mode?
+              prepared_types_from(Array(@attribute.consists_of.fetch(:type, [])))
+            else
+              prepared_types_from(@types)
+            end
+        end
+
+        def prepared_types_from(types)
+          types.map do |type|
+            if type.is_a?(String)
+              Object.const_get(type)
+            else
+              type
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/servactory/methods/workspace.rb

@@ -3,6 +3,8 @@
 module Servactory
   module Methods
     module Workspace
+      private
+
       def call!(collection_of_stages:, **)
         super
 

data/lib/servactory/outputs/dsl.rb

@@ -17,7 +17,12 @@ module Servactory
         private
 
         def output(name, **options)
-          collection_of_outputs << Output.new(name, **options)
+          collection_of_outputs << Output.new(
+            name,
+            collection_mode_class_names: config.collection_mode_class_names,
+            hash_mode_class_names: config.hash_mode_class_names,
+            **options
+          )
         end
 
         def collection_of_outputs