servactory 1.1.0

data/lib/servactory/input_arguments/input_argument.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Servactory
+  module InputArguments
+    class InputArgument
+      attr_reader :name,
+                  :types,
+                  :inclusion,
+                  :must,
+                  :array,
+                  :required,
+                  :internal,
+                  :default
+
+      def initialize(name, type:, **options)
+        @name = name
+        @types = Array(type)
+
+        @inclusion = options.fetch(:inclusion, nil)
+        @must = options.fetch(:must, nil)
+        @array = options.fetch(:array, false)
+        @required = options.fetch(:required, true)
+        @internal = options.fetch(:internal, false)
+        @default = options.fetch(:default, nil)
+      end
+
+      def options_for_checks
+        {
+          types:,
+          inclusion:,
+          must:,
+          required:,
+          # internal:,
+          default:
+        }
+      end
+
+      def conflict_code
+        return :required_vs_default if required? && default_value_present?
+        return :array_vs_array if array? && types.include?(Array)
+        return :array_vs_inclusion if array? && inclusion_present?
+
+        nil
+      end
+
+      def inclusion_present?
+        inclusion.is_a?(Array) && inclusion.present?
+      end
+
+      def must_present?
+        must.present?
+      end
+
+      def array?
+        Servactory::Utils.boolean?(array)
+      end
+
+      def required?
+        Servactory::Utils.boolean?(required)
+      end
+
+      def optional?
+        !required?
+      end
+
+      def internal?
+        Servactory::Utils.boolean?(internal)
+      end
+
+      def default_value_present?
+        !default.nil?
+      end
+
+      def with_conflicts?
+        conflict_code.present?
+      end
+    end
+  end
+end

data/lib/servactory/input_arguments/tools/check.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Servactory
+  module InputArguments
+    module Tools
+      class Check
+        def self.check!(...)
+          new(...).check!
+        end
+
+        def initialize(context, incoming_arguments, collection_of_input_arguments)
+          @context = context
+          @incoming_arguments = incoming_arguments
+          @collection_of_input_arguments = collection_of_input_arguments
+
+          @errors = []
+        end
+
+        def check!
+          @collection_of_input_arguments.each do |input|
+            process_input(input)
+          end
+
+          raise_errors
+        end
+
+        private
+
+        def process_input(input)
+          input.options_for_checks.each do |check_key, check_options|
+            process_option(check_key, check_options, input:)
+          end
+        end
+
+        def process_option(check_key, check_options, input:)
+          check_classes.each do |check_class|
+            errors_from_checks = process_check_class(check_class, input:, check_key:, check_options:)
+
+            @errors.push(*errors_from_checks)
+          end
+        end
+
+        def process_check_class(check_class, input:, check_key:, check_options:)
+          check_class.check(
+            context: @context,
+            input:,
+            value: @incoming_arguments.fetch(input.name, nil),
+            check_key:,
+            check_options:
+          )
+        end
+
+        ########################################################################
+
+        def check_classes
+          [
+            Servactory::InputArguments::Checks::Required,
+            Servactory::InputArguments::Checks::Type,
+            Servactory::InputArguments::Checks::Inclusion,
+            Servactory::InputArguments::Checks::Must
+          ]
+        end
+
+        ########################################################################
+
+        def raise_errors
+          return if @errors.empty?
+
+          raise Servactory.configuration.input_argument_error_class, @errors.first
+        end
+      end
+    end
+  end
+end

data/lib/servactory/input_arguments/tools/find_unnecessary.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Servactory
+  module InputArguments
+    module Tools
+      class FindUnnecessary
+        def self.check!(...)
+          new(...).check!
+        end
+
+        def initialize(context, incoming_arguments, collection_of_input_arguments)
+          @context = context
+          @incoming_arguments = incoming_arguments
+          @collection_of_input_arguments = collection_of_input_arguments
+        end
+
+        def check!
+          return if unnecessary_attributes.empty?
+
+          raise Servactory.configuration.input_argument_error_class,
+                "[#{@context.class.name}] Unexpected attributes: `#{unnecessary_attributes.join(', ')}`"
+        end
+
+        private
+
+        def unnecessary_attributes
+          @unnecessary_attributes ||= @incoming_arguments.keys - @collection_of_input_arguments.names
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Servactory
+  module InputArguments
+    module Tools
+      class Prepare
+        def self.prepare(...)
+          new(...).prepare
+        end
+
+        def initialize(context, incoming_arguments, collection_of_input_arguments)
+          @context = context
+          @incoming_arguments = incoming_arguments
+          @collection_of_input_arguments = collection_of_input_arguments
+        end
+
+        def prepare
+          @inputs_variables = {}
+          @internal_variables = {}
+
+          @collection_of_input_arguments.each do |input|
+            process_input(input)
+          end
+
+          create_instance_variables
+        end
+
+        private
+
+        def process_input(input)
+          input_value = @incoming_arguments.fetch(input.name, nil)
+          input_value = input.default if input.optional? && input_value.blank?
+
+          @inputs_variables[input.name] = input_value
+
+          return unless input.internal?
+
+          @internal_variables[input.name] = input_value
+        end
+
+        def create_instance_variables
+          Servactory::Inputs.class_eval(class_inputs_template)
+
+          @context.assign_inputs(Servactory::Inputs.new(**@inputs_variables))
+
+          @context.class.class_eval(context_internal_variables_template)
+
+          @internal_variables.each do |input_name, input_value|
+            @context.instance_variable_set(:"@#{input_name}", input_value)
+          end
+        end
+
+        ########################################################################
+
+        # EXAMPLE:
+        #
+        #   attr_reader(*[:attr_1]); def initialize(attr_1); @attr_1 = attr_1; end
+        #
+        # OR
+        #
+        #   attr_reader(*[:attr_1, :attr_2, :attr_3])
+        #
+        #   def initialize(attr_1:, attr_2:, attr_3:)
+        #     @attr_1 = attr_1; @attr_2 = attr_2; @attr_3 = attr_3;
+        #   end
+        #
+        def class_inputs_template
+          <<-RUBY.squish
+            attr_reader(*#{@inputs_variables.keys});
+
+            def initialize(#{@inputs_variables.keys.join(':, ')}:);
+              #{@inputs_variables.keys.map { |key| "@#{key} = #{key}" }.join('; ')};
+            end
+          RUBY
+        end
+
+        # EXAMPLE:
+        #
+        #   private attr_reader(*[:attr_1]);
+        #
+        def context_internal_variables_template
+          <<-RUBY.squish
+            private attr_reader(*#{@internal_variables.keys});
+          RUBY
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Servactory
+  module InputArguments
+    module Tools
+      class Rules
+        def self.check!(...)
+          new(...).check!
+        end
+
+        def initialize(context, collection_of_input_arguments)
+          @context = context
+          @collection_of_input_arguments = collection_of_input_arguments
+        end
+
+        def check!
+          @collection_of_input_arguments.each do |input_argument|
+            check_for!(input_argument)
+          end
+        end
+
+        private
+
+        def check_for!(input_argument)
+          return unless input_argument.with_conflicts?
+
+          raise_error_for(input_argument)
+        end
+
+        def raise_error_for(input_argument)
+          raise Servactory.configuration.input_argument_error_class,
+                "[#{@context.class.name}] Conflict in `#{input_argument.name}` input " \
+                "options: `#{input_argument.conflict_code}`"
+        end
+      end
+    end
+  end
+end

data/lib/servactory/input_arguments/workbench.rb

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

data/lib/servactory/inputs.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Servactory
+  class Inputs # rubocop:disable Lint/EmptyClass
+    # NOTE: Look at the file `lib/servactory/input_arguments/tools/prepare.rb`
+  end
+end

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

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

data/lib/servactory/internal_arguments/checks/type.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Servactory
+  module InternalArguments
+    module Checks
+      class Type < Base
+        DEFAULT_MESSAGE = lambda do |service_class_name:, internal_argument:, expected_type:, given_type:|
+          "The \"#{internal_argument.name}\" internal argument on \"#{service_class_name}\" must be of type " \
+            "\"#{expected_type}\" but was \"#{given_type}\""
+        end
+
+        private_constant :DEFAULT_MESSAGE
+
+        def self.check!(...)
+          new(...).check!
+        end
+
+        ##########################################################################
+
+        def initialize(context:, internal_argument:, value:)
+          super()
+
+          @context = context
+          @internal_argument = internal_argument
+          @value = value
+        end
+
+        def check!
+          return if prepared_types.any? { |type| @value.is_a?(type) }
+
+          raise_error_with(
+            DEFAULT_MESSAGE,
+            service_class_name: @context.class.name,
+            internal_argument: @internal_argument,
+            expected_type: prepared_types.join(", "),
+            given_type: @value.class.name
+          )
+        end
+
+        private
+
+        def prepared_types
+          @prepared_types ||=
+            Array(@internal_argument.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/internal_arguments/collection.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Servactory
+  module InternalArguments
+    class Collection
+      # NOTE: http://words.steveklabnik.com/beware-subclassing-ruby-core-classes
+      extend Forwardable
+      def_delegators :@collection, :<<, :each, :map
+
+      def initialize(*)
+        @collection = []
+      end
+
+      def names
+        map(&:name)
+      end
+    end
+  end
+end

data/lib/servactory/internal_arguments/dsl.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Servactory
+  module InternalArguments
+    module DSL
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        private
+
+        def internal(name, **options)
+          collection_of_internal_arguments << InternalArgument.new(name, **options)
+        end
+
+        def collection_of_internal_arguments
+          @collection_of_internal_arguments ||= Collection.new
+        end
+
+        def internal_arguments_workbench
+          @internal_arguments_workbench ||= Workbench.work_with(collection_of_internal_arguments)
+        end
+      end
+    end
+  end
+end

data/lib/servactory/internal_arguments/internal_argument.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Servactory
+  module InternalArguments
+    class InternalArgument
+      attr_reader :name,
+                  :types,
+                  :required
+
+      def initialize(name, type:, **options)
+        @name = name
+        @types = Array(type)
+
+        @required = options.fetch(:required, true)
+      end
+
+      def options_for_checks
+        {
+          types:,
+          required:
+        }
+      end
+
+      def required?
+        required
+      end
+
+      def optional?
+        !required
+      end
+    end
+  end
+end

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

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

data/lib/servactory/internal_arguments/workbench.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Servactory
+  module InternalArguments
+    class Workbench
+      def self.work_with(...)
+        new(...)
+      end
+
+      def initialize(collection_of_internal_arguments)
+        @collection_of_internal_arguments = collection_of_internal_arguments
+      end
+
+      def assign(context:)
+        @context = context
+      end
+
+      def prepare
+        Tools::Prepare.prepare(context, collection_of_internal_arguments)
+      end
+
+      private
+
+      attr_reader :context, :collection_of_internal_arguments
+    end
+  end
+end

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

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

data/lib/servactory/output_arguments/checks/type.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Servactory
+  module OutputArguments
+    module Checks
+      class Type < Base
+        DEFAULT_MESSAGE = lambda do |service_class_name:, output_argument:, expected_type:, given_type:|
+          "The \"#{output_argument.name}\" output argument on \"#{service_class_name}\" must be of type " \
+            "\"#{expected_type}\" but was \"#{given_type}\""
+        end
+
+        private_constant :DEFAULT_MESSAGE
+
+        def self.check!(...)
+          new(...).check!
+        end
+
+        ##########################################################################
+
+        def initialize(context:, output_argument:, value:)
+          super()
+
+          @context = context
+          @output_argument = output_argument
+          @value = value
+        end
+
+        def check!
+          return if prepared_types.any? { |type| @value.is_a?(type) }
+
+          raise_error_with(
+            DEFAULT_MESSAGE,
+            service_class_name: @context.class.name,
+            output_argument: @output_argument,
+            expected_type: prepared_types.join(", "),
+            given_type: @value.class.name
+          )
+        end
+
+        private
+
+        def prepared_types
+          @prepared_types ||=
+            Array(@output_argument.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/output_arguments/collection.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Servactory
+  module OutputArguments
+    class Collection
+      # NOTE: http://words.steveklabnik.com/beware-subclassing-ruby-core-classes
+      extend Forwardable
+      def_delegators :@collection, :<<, :each, :map
+
+      def initialize(*)
+        @collection = []
+      end
+
+      def names
+        map(&:name)
+      end
+    end
+  end
+end