servactory 1.5.2 → 1.6.0

data/lib/servactory/{input_arguments → inputs}/checks/must.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
 module Servactory
-  module InputArguments
+  module Inputs
     module Checks
       class Must < Base
         DEFAULT_MESSAGE = lambda do |service_class_name:, input:, value:, code:|
           I18n.t(
-            "servactory.input_arguments.checks.must.default_error",
+            "servactory.inputs.checks.must.default_error",
             service_class_name: service_class_name,
             input_name: input.name,
             value: value,
@@ -16,7 +16,7 @@ module Servactory
 
         SYNTAX_ERROR_MESSAGE = lambda do |service_class_name:, input:, value:, code:, exception_message:|
           I18n.t(
-            "servactory.input_arguments.checks.must.syntax_error",
+            "servactory.inputs.checks.must.syntax_error",
             service_class_name: service_class_name,
             input_name: input.name,
             value: value,

data/lib/servactory/{input_arguments → inputs}/checks/required.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 module Servactory
-  module InputArguments
+  module Inputs
     module Checks
       class Required < Base
         DEFAULT_MESSAGE = lambda do |service_class_name:, input:, value:|
-          i18n_key = "servactory.input_arguments.checks.required.default_error."
+          i18n_key = "servactory.inputs.checks.required.default_error."
           i18n_key += input.array? && value.present? ? "for_array" : "default"
 
           I18n.t(

data/lib/servactory/{input_arguments → inputs}/checks/type.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Servactory
-  module InputArguments
+  module Inputs
     module Checks
       class Type < Base
         DEFAULT_MESSAGE = lambda do |service_class_name:, input:, expected_type:, given_type:|
@@ -14,7 +14,7 @@ module Servactory
               array_message
             else
               I18n.t(
-                "servactory.input_arguments.checks.type.default_error.for_array",
+                "servactory.inputs.checks.type.default_error.for_array",
                 service_class_name: service_class_name,
                 input_name: input.name,
                 expected_type: expected_type,
@@ -23,7 +23,7 @@ module Servactory
             end
           else
             I18n.t(
-              "servactory.input_arguments.checks.type.default_error.default",
+              "servactory.inputs.checks.type.default_error.default",
               service_class_name: service_class_name,
               input_name: input.name,
               expected_type: expected_type,

data/lib/servactory/{input_arguments → inputs}/collection.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Servactory
-  module InputArguments
+  module Inputs
     class Collection
       # NOTE: http://words.steveklabnik.com/beware-subclassing-ruby-core-classes
       extend Forwardable

data/lib/servactory/{input_arguments → inputs}/define_input_conflict.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Servactory
-  module InputArguments
+  module Inputs
     class DefineInputConflict
       attr_reader :content
 

data/lib/servactory/{input_arguments → inputs}/define_input_method.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Servactory
-  module InputArguments
+  module Inputs
     class DefineInputMethod
       attr_reader :name,
                   :content

data/lib/servactory/inputs/dsl.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Inputs
+    module DSL
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def inherited(child)
+          super
+
+          child.send(:collection_of_inputs).merge(collection_of_inputs)
+        end
+
+        private
+
+        def input(name, **options)
+          collection_of_inputs << Input.new(
+            name,
+            **options
+          )
+        end
+
+        def collection_of_inputs
+          @collection_of_inputs ||= Collection.new
+        end
+
+        def inputs_workbench
+          @inputs_workbench ||= Workbench.work_with(collection_of_inputs)
+        end
+      end
+    end
+  end
+end

data/lib/servactory/{input_arguments/input_argument.rb → inputs/input.rb}

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module Servactory
-  module InputArguments
-    class InputArgument # rubocop:disable Metrics/ClassLength
+  module Inputs
+    class Input # rubocop:disable Metrics/ClassLength
       ARRAY_DEFAULT_VALUE = ->(is: false, message: nil) { { is: is, message: message } }
 
       attr_reader :name,
@@ -29,18 +29,18 @@ module Servactory
       # rubocop:enable Style/KeywordParametersOrder
 
       def add_basic_options_with(type:, options:)
-        # Check Class: Servactory::InputArguments::Checks::Required
+        # Check Class: Servactory::Inputs::Checks::Required
         add_required_option_with(options)
 
-        # Check Class: Servactory::InputArguments::Checks::Type
+        # Check Class: Servactory::Inputs::Checks::Type
         add_types_option_with(type)
         add_default_option_with(options)
         add_array_option_with(options)
 
-        # Check Class: Servactory::InputArguments::Checks::Inclusion
+        # Check Class: Servactory::Inputs::Checks::Inclusion
         add_inclusion_option_with(options)
 
-        # Check Class: Servactory::InputArguments::Checks::Must
+        # Check Class: Servactory::Inputs::Checks::Must
         add_must_option_with(options)
 
         # Check Class: nil
@@ -51,7 +51,7 @@ module Servactory
         collection_of_options << Option.new(
           name: :required,
           input: self,
-          check_class: Servactory::InputArguments::Checks::Required,
+          check_class: Servactory::Inputs::Checks::Required,
           define_input_methods: [
             DefineInputMethod.new(
               name: :required?,
@@ -76,7 +76,7 @@ module Servactory
         collection_of_options << Option.new(
           name: :types,
           input: self,
-          check_class: Servactory::InputArguments::Checks::Type,
+          check_class: Servactory::Inputs::Checks::Type,
           original_value: Array(type),
           need_for_checks: true,
           value_fallback: nil,
@@ -88,7 +88,7 @@ module Servactory
         collection_of_options << Option.new(
           name: :default,
           input: self,
-          check_class: Servactory::InputArguments::Checks::Type,
+          check_class: Servactory::Inputs::Checks::Type,
           define_input_methods: [
             DefineInputMethod.new(
               name: :default_value_present?,
@@ -106,7 +106,7 @@ module Servactory
         collection_of_options << Option.new(
           name: :array,
           input: self,
-          check_class: Servactory::InputArguments::Checks::Type,
+          check_class: Servactory::Inputs::Checks::Type,
           define_input_methods: [
             DefineInputMethod.new(
               name: :array?,
@@ -128,7 +128,7 @@ module Servactory
         collection_of_options << Option.new(
           name: :inclusion,
           input: self,
-          check_class: Servactory::InputArguments::Checks::Inclusion,
+          check_class: Servactory::Inputs::Checks::Inclusion,
           define_input_methods: [
             DefineInputMethod.new(
               name: :inclusion_present?,
@@ -146,7 +146,7 @@ module Servactory
         collection_of_options << Option.new(
           name: :must,
           input: self,
-          check_class: Servactory::InputArguments::Checks::Must,
+          check_class: Servactory::Inputs::Checks::Must,
           define_input_methods: [
             DefineInputMethod.new(
               name: :must_present?,

data/lib/servactory/{input_arguments → inputs}/option.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Servactory
-  module InputArguments
+  module Inputs
     class Option
       DEFAULT_VALUE = ->(key:, value:, message: nil) { { key => value, message: message } }
 
@@ -66,10 +66,12 @@ module Servactory
 
       def prepare_advanced_for(value:, value_fallback:)
         if value.is_a?(Hash)
+          message = value.fetch(:message, nil)
+
           DEFAULT_VALUE.call(
             key: value_key,
-            value: value.fetch(value_key, value_fallback),
-            message: value.fetch(:message, nil)
+            value: value.fetch(value_key, message.present? ? true : value_fallback),
+            message: message
           )
         else
           DEFAULT_VALUE.call(key: value_key, value: value)

data/lib/servactory/{input_arguments → inputs}/options_collection.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Servactory
-  module InputArguments
+  module Inputs
     class OptionsCollection
       # NOTE: http://words.steveklabnik.com/beware-subclassing-ruby-core-classes
       extend Forwardable

data/lib/servactory/{input_arguments → inputs}/tools/check.rb

@@ -1,21 +1,21 @@
 # frozen_string_literal: true
 
 module Servactory
-  module InputArguments
+  module Inputs
     module Tools
       class Check
         def self.check!(...)
           new(...).check!
         end
 
-        def initialize(context, incoming_arguments, collection_of_input_arguments)
+        def initialize(context, incoming_arguments, collection_of_inputs)
           @context = context
           @incoming_arguments = incoming_arguments
-          @collection_of_input_arguments = collection_of_input_arguments
+          @collection_of_inputs = collection_of_inputs
         end
 
         def check!
-          @collection_of_input_arguments.each do |input|
+          @collection_of_inputs.each do |input|
             process_input(input)
           end
 
@@ -68,7 +68,7 @@ module Servactory
         def raise_errors
           return if (tmp_errors = errors.not_blank).empty?
 
-          raise Servactory.configuration.input_argument_error_class, tmp_errors.first
+          raise Servactory.configuration.input_error_class.new(message: tmp_errors.first)
         end
       end
     end

data/lib/servactory/{input_arguments → inputs}/tools/check_errors.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Servactory
-  module InputArguments
+  module Inputs
     module Tools
       class CheckErrors
         # NOTE: http://words.steveklabnik.com/beware-subclassing-ruby-core-classes

data/lib/servactory/{input_arguments → inputs}/tools/find_unnecessary.rb

@@ -1,35 +1,35 @@
 # frozen_string_literal: true
 
 module Servactory
-  module InputArguments
+  module Inputs
     module Tools
       class FindUnnecessary
         def self.check!(...)
           new(...).check!
         end
 
-        def initialize(context, incoming_arguments, collection_of_input_arguments)
+        def initialize(context, incoming_arguments, collection_of_inputs)
           @context = context
           @incoming_arguments = incoming_arguments
-          @collection_of_input_arguments = collection_of_input_arguments
+          @collection_of_inputs = collection_of_inputs
         end
 
         def check!
           return if unnecessary_attributes.empty?
 
           message_text = I18n.t(
-            "servactory.input_arguments.tools.find_unnecessary.error",
+            "servactory.inputs.tools.find_unnecessary.error",
             service_class_name: @context.class.name,
             unnecessary_attributes: unnecessary_attributes.join(", ")
           )
 
-          raise Servactory.configuration.input_argument_error_class, message_text
+          raise Servactory.configuration.input_error_class.new(message: message_text)
         end
 
         private
 
         def unnecessary_attributes
-          @unnecessary_attributes ||= @incoming_arguments.keys - @collection_of_input_arguments.names
+          @unnecessary_attributes ||= @incoming_arguments.keys - @collection_of_inputs.names
         end
       end
     end

data/lib/servactory/{input_arguments → inputs}/tools/prepare.rb

@@ -1,24 +1,24 @@
 # frozen_string_literal: true
 
 module Servactory
-  module InputArguments
+  module Inputs
     module Tools
       class Prepare
         def self.prepare(...)
           new(...).prepare
         end
 
-        def initialize(context, incoming_arguments, collection_of_input_arguments)
+        def initialize(context, incoming_arguments, collection_of_inputs)
           @context = context
           @incoming_arguments = incoming_arguments
-          @collection_of_input_arguments = collection_of_input_arguments
+          @collection_of_inputs = collection_of_inputs
         end
 
         def prepare
           @inputs_variables = {}
           @internal_variables = {}
 
-          @collection_of_input_arguments.each do |input|
+          @collection_of_inputs.each do |input|
             process_input(input)
           end
 
@@ -39,7 +39,7 @@ module Servactory
         end
 
         def create_instance_variables
-          inputs_class = Servactory::Inputs.dup
+          inputs_class = Servactory::Context::Workspace::Inputs.dup
           inputs_class.class_eval(class_inputs_template) if class_inputs_template.present?
 
           @context.assign_inputs(inputs_class.new(**@inputs_variables))

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Inputs
+    module Tools
+      class Rules
+        def self.check!(...)
+          new(...).check!
+        end
+
+        def initialize(context, collection_of_inputs)
+          @context = context
+          @collection_of_inputs = collection_of_inputs
+        end
+
+        def check!
+          @collection_of_inputs.each do |input|
+            check_for!(input)
+          end
+        end
+
+        private
+
+        def check_for!(input)
+          return unless input.with_conflicts?
+
+          raise_error_for(input)
+        end
+
+        def raise_error_for(input)
+          message_text = I18n.t(
+            "servactory.inputs.tools.rules.error",
+            service_class_name: @context.class.name,
+            input_name: input.name,
+            conflict_code: input.conflict_code
+          )
+
+          raise Servactory.configuration.input_error_class.new(
+            message: message_text,
+            input_name: input.name
+          )
+        end
+      end
+    end
+  end
+end

data/lib/servactory/{input_arguments → inputs}/workbench.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
 module Servactory
-  module InputArguments
+  module Inputs
     class Workbench
       def self.work_with(...)
         new(...)
       end
 
-      def initialize(collection_of_input_arguments)
-        @collection_of_input_arguments = collection_of_input_arguments
+      def initialize(collection_of_inputs)
+        @collection_of_inputs = collection_of_inputs
       end
 
       def assign(context:, arguments:)
@@ -17,25 +17,25 @@ module Servactory
       end
 
       def find_unnecessary!
-        Tools::FindUnnecessary.check!(context, @incoming_arguments, collection_of_input_arguments)
+        Tools::FindUnnecessary.check!(context, @incoming_arguments, collection_of_inputs)
       end
 
       def check_rules!
-        Tools::Rules.check!(context, collection_of_input_arguments)
+        Tools::Rules.check!(context, collection_of_inputs)
       end
 
       def prepare
-        Tools::Prepare.prepare(context, @incoming_arguments, collection_of_input_arguments)
+        Tools::Prepare.prepare(context, @incoming_arguments, collection_of_inputs)
       end
 
       def check!
-        Tools::Check.check!(context, @incoming_arguments, collection_of_input_arguments)
+        Tools::Check.check!(context, @incoming_arguments, collection_of_inputs)
       end
 
       private
 
       attr_reader :context,
-                  :collection_of_input_arguments
+                  :collection_of_inputs
     end
   end
 end

data/lib/servactory/internals/checks/base.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Internals
+    module Checks
+      class Base
+        protected
+
+        def raise_error_with(message, **attributes)
+          message = message.call(**attributes) if message.is_a?(Proc)
+
+          raise Servactory.configuration.internal_error_class.new(message: message)
+        end
+      end
+    end
+  end
+end

data/lib/servactory/{internal_arguments → internals}/checks/type.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
 module Servactory
-  module InternalArguments
+  module Internals
     module Checks
       class Type < Base
-        DEFAULT_MESSAGE = lambda do |service_class_name:, internal_argument:, expected_type:, given_type:|
+        DEFAULT_MESSAGE = lambda do |service_class_name:, internal:, expected_type:, given_type:|
           I18n.t(
-            "servactory.internal_arguments.checks.type.default_error",
+            "servactory.internals.checks.type.default_error",
             service_class_name: service_class_name,
-            internal_argument_name: internal_argument.name,
+            internal_name: internal.name,
             expected_type: expected_type,
             given_type: given_type
           )
@@ -22,11 +22,11 @@ module Servactory
 
         ##########################################################################
 
-        def initialize(context:, internal_argument:, value:)
+        def initialize(context:, internal:, value:)
           super()
 
           @context = context
-          @internal_argument = internal_argument
+          @internal = internal
           @value = value
         end
 
@@ -36,7 +36,7 @@ module Servactory
           raise_error_with(
             DEFAULT_MESSAGE,
             service_class_name: @context.class.name,
-            internal_argument: @internal_argument,
+            internal: @internal,
             expected_type: prepared_types.join(", "),
             given_type: @value.class.name
           )
@@ -46,7 +46,7 @@ module Servactory
 
         def prepared_types
           @prepared_types ||=
-            Array(@internal_argument.types).map do |type|
+            Array(@internal.types).map do |type|
               if type.is_a?(String)
                 Object.const_get(type)
               else

data/lib/servactory/{output_arguments → internals}/collection.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Servactory
-  module OutputArguments
+  module Internals
     class Collection
       # NOTE: http://words.steveklabnik.com/beware-subclassing-ruby-core-classes
       extend Forwardable

data/lib/servactory/internals/dsl.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Internals
+    module DSL
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def inherited(child)
+          super
+
+          child.send(:collection_of_internals).merge(collection_of_internals)
+        end
+
+        private
+
+        def internal(name, **options)
+          collection_of_internals << Internal.new(name, **options)
+        end
+
+        def collection_of_internals
+          @collection_of_internals ||= Collection.new
+        end
+
+        def internals_workbench
+          @internals_workbench ||= Workbench.work_with(collection_of_internals)
+        end
+      end
+    end
+  end
+end

data/lib/servactory/{internal_arguments/internal_argument.rb → internals/internal.rb}

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module Servactory
-  module InternalArguments
-    class InternalArgument
+  module Internals
+    class Internal
       attr_reader :name,
                   :types,
                   :required

data/lib/servactory/internals/tools/prepare.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Internals
+    module Tools
+      class Prepare
+        def self.prepare(...)
+          new(...).prepare
+        end
+
+        def initialize(context, collection_of_internals)
+          @context = context
+          @collection_of_internals = collection_of_internals
+        end
+
+        def prepare
+          @collection_of_internals.each do |internal|
+            create_instance_variable_for(internal)
+          end
+        end
+
+        private
+
+        def create_instance_variable_for(internal)
+          @context.instance_variable_set(:"@#{internal.name}", nil)
+
+          @context.class.class_eval(context_internal_template_for(internal))
+        end
+
+        # EXAMPLE:
+        #
+        #   define_method(:user=) do |value|
+        #     Servactory::Internals::Checks::Type.check!( context: self, internal:, value: )
+        #
+        #     instance_variable_set(:@user, value)
+        #   end
+        #
+        #   private attr_reader :user
+        #
+        def context_internal_template_for(internal)
+          <<-RUBY
+            define_method(:#{internal.name}=) do |value|
+              Servactory::Internals::Checks::Type.check!(
+                context: self,
+                internal: internal,
+                value: value
+              )
+
+              instance_variable_set(:@#{internal.name}, value)
+            end
+
+            private
+
+            attr_reader :#{internal.name}
+          RUBY
+        end
+      end
+    end
+  end
+end