servactory 1.9.6 → 2.0.0.rc2

data/lib/servactory/internals/validations/type.rb

@@ -4,22 +4,63 @@ module Servactory
   module Internals
     module Validations
       class Type < Base
-        DEFAULT_MESSAGE = lambda do |service_class_name:, internal:, expected_type:, given_type:|
-          I18n.t(
-            "servactory.internals.checks.type.default_error",
-            service_class_name: service_class_name,
-            internal_name: internal.name,
-            expected_type: expected_type,
-            given_type: given_type
-          )
+        DEFAULT_MESSAGE = lambda do |service_class_name:, internal:, value:, key_name:, expected_type:, given_type:| # rubocop:disable Metrics/BlockLength
+          if internal.collection_mode?
+            collection_message = internal.consists_of.fetch(:message)
+
+            if collection_message.is_a?(Proc)
+              collection_message.call(internal: internal, expected_type: expected_type)
+            elsif collection_message.is_a?(String) && collection_message.present?
+              collection_message
+            elsif value.is_a?(internal.types.fetch(0, Array))
+              I18n.t(
+                "servactory.internals.checks.type.default_error.for_collection.wrong_element_type",
+                service_class_name: service_class_name,
+                internal_name: internal.name,
+                expected_type: expected_type,
+                given_type: given_type
+              )
+            else
+              I18n.t(
+                "servactory.internals.checks.type.default_error.for_collection.wrong_type",
+                service_class_name: service_class_name,
+                internal_name: internal.name,
+                expected_type: internal.types.fetch(0, Array),
+                given_type: value.class.name
+              )
+            end
+          elsif internal.hash_mode? && key_name.present?
+            I18n.t(
+              "servactory.internals.checks.type.default_error.for_hash.wrong_element_type",
+              service_class_name: service_class_name,
+              internal_name: internal.name,
+              key_name: key_name,
+              expected_type: expected_type,
+              given_type: given_type
+            )
+          else
+            I18n.t(
+              "servactory.internals.checks.type.default_error.default",
+              service_class_name: service_class_name,
+              internal_name: internal.name,
+              expected_type: expected_type,
+              given_type: given_type
+            )
+          end
         end
 
         private_constant :DEFAULT_MESSAGE
 
         def self.validate!(...)
+          return unless should_be_checked?
+
           new(...).validate!
         end
 
+        def self.should_be_checked?
+          true
+        end
+
         ##########################################################################
 
         def initialize(context:, internal:, value:)
@@ -30,38 +71,78 @@ module Servactory
           @value = value
         end
 
-        def validate!
-          return unless should_be_checked?
+        def validate! # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          object_schema_validator = nil
+
+          return if prepared_types.any? do |type|
+            if @internal.collection_mode?
+              @value.is_a?(@internal.types.fetch(0, Array)) &&
+              @value.respond_to?(:all?) && @value.all?(type)
+            elsif @internal.hash_mode?
+              object_schema_validator = Servactory::Maintenance::Validations::ObjectSchema.validate(
+                object: @value,
+                schema: @internal.schema
+              )
+
+              object_schema_validator.valid?
+            else
+              @value.is_a?(type)
+            end
+          end
+
+          if (first_error = object_schema_validator&.errors&.first).present?
+            raise_default_object_error_with(first_error)
+          end
+
+          raise_default_error
+        end
+
+        private
 
-          return if prepared_types.any? { |type| @value.is_a?(type) }
+        def prepared_types
+          @prepared_types ||=
+            if @internal.collection_mode?
+              prepared_types_from(Array(@internal.consists_of.fetch(:type, [])))
+            else
+              prepared_types_from(@internal.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
+
+        ########################################################################
+
+        def raise_default_object_error_with(error)
           raise_error_with(
             DEFAULT_MESSAGE,
             service_class_name: @context.class.name,
             internal: @internal,
-            expected_type: prepared_types.join(", "),
-            given_type: @value.class.name
+            value: @value,
+            key_name: error.fetch(:name),
+            expected_type: error.fetch(:expected_type),
+            given_type: error.fetch(:given_type)
           )
         end
 
-        private
-
-        def should_be_checked?
-          @internal.required? || (
-            @internal.optional? && !@value.nil?
+        def raise_default_error
+          raise_error_with(
+            DEFAULT_MESSAGE,
+            service_class_name: @context.class.name,
+            internal: @internal,
+            value: @value,
+            key_name: nil,
+            expected_type: prepared_types.join(", "),
+            given_type: @value.class.name
           )
         end
-
-        def prepared_types
-          @prepared_types ||=
-            Array(@internal.types).map do |type|
-              if type.is_a?(String)
-                Object.const_get(type)
-              else
-                type
-              end
-            end
-        end
       end
     end
   end

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/object_schema.rb

@@ -0,0 +1,119 @@
+# 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
+
+          @valid = false
+          @errors = []
+        end
+
+        def validate
+          @valid = validate_for(object: @object, schema: @schema)
+
+          self
+        end
+
+        def valid?
+          @valid
+        end
+
+        private
+
+        def validate_for(object:, schema:, root_schema_key: nil) # rubocop:disable Metrics/MethodLength
+          unless object.respond_to?(:fetch)
+            add_error(name: root_schema_key, expected_type: Hash, given_type: object.class)
+            return false
+          end
+
+          schema.all? 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)
+              )
+
+              unless is_success
+                add_error(
+                  name: schema_key,
+                  expected_type: attribute_type,
+                  given_type: object.fetch(schema_key, nil).class
+                )
+              end
+
+              is_success
+            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(name:, expected_type:, given_type:)
+          @errors << {
+            name: name,
+            expected_type: expected_type,
+            given_type: given_type
+          }
+        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