servactory 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e9766f87f647b0873a6671d88811141a77b571fb15ac5ee6b10b78e2e5696ca6
-  data.tar.gz: c36ee73abad2d9241f6b48190cbf3351fe8c9c40bc7cb9bdfdfb09c04e5d05f8
+  metadata.gz: d4ffa3b926585163837e461a8a1b129a81f951f88a8d715dd6e74297e0a37ddd
+  data.tar.gz: 1d1a3326828e282ad0f46bc76e2754fb44e0dbd5f2e00c452cd6e856866bcbbd
 SHA512:
-  metadata.gz: 11b27258c9a302cb989eed03fe4f1325c03855f58fd3a79b6cad7a3846fa8e9395f780fe0d9a2dd30c9b044d4e98df4677857c93c275f9bfe8780d6ebefe5d5e
-  data.tar.gz: 57800e68b8c8bece089513dcf0b0ff8da6ab2efb33a4d4a694b11995dae51b7dd0496b1b0f4b6c0ba403db5c6037432e43371d68bea5b56bb05844d98fb36e8e
+  metadata.gz: 07c4e1f255a4fabe953a3c1381229000b564b80fc0e4f1c08547fed23dcc9cb9b31ebab678d76f894ce55e5506120d412fab26bf214f433f00cf43d958b502d7
+  data.tar.gz: 85cadb2169b968a0e9cda6f9279d9be37b01acdc0f7f91ca2b7f8458e89a219213ad317b84002d1b7684bb695a73b4c5a3a6c092a4e3a61c05984e2ee027a164

data/README.md

@@ -2,6 +2,28 @@
 
 A set of tools for building reliable services of any complexity.
 
+[![Gem version](https://img.shields.io/gem/v/servactory?logo=rubygems&logoColor=fff)](https://rubygems.org/gems/servactory)
+
+## Contents
+
+- [Requirements](https://github.com/afuno/servactory/edit/main/README.md#requirements)
+- [Getting started](https://github.com/afuno/servactory/edit/main/README.md#getting-started)
+  - [Conventions](https://github.com/afuno/servactory/edit/main/README.md#conventions)
+  - [Installation](https://github.com/afuno/servactory/edit/main/README.md#installation)
+  - [Preparation](https://github.com/afuno/servactory/edit/main/README.md#preparation)
+- [Usage](https://github.com/afuno/servactory/edit/main/README.md#usage)
+  - [Minimal example](https://github.com/afuno/servactory#minimal-example)
+  - [Input attributes](https://github.com/afuno/servactory#input-attributes)
+    - [Isolated usage](https://github.com/afuno/servactory#isolated-usage)
+    - [As an internal argument](https://github.com/afuno/servactory#isolated-usage)
+    - [Optional inputs](https://github.com/afuno/servactory#optional-inputs)
+    - [An array of specific values](https://github.com/afuno/servactory#an-array-of-specific-values)
+    - [Inclusion](https://github.com/afuno/servactory#inclusion)
+    - [Must](https://github.com/afuno/servactory#must)
+  - [Output attributes](https://github.com/afuno/servactory/edit/main/README.md#output-attributes)
+  - [Internal attributes](https://github.com/afuno/servactory/edit/main/README.md#internal-attributes)
+  - [Result](https://github.com/afuno/servactory/edit/main/README.md#result)
+
 ## Requirements
 
 - Ruby >= 2.7
@@ -70,7 +92,7 @@ end
 ### Minimal example
 
 ```ruby
-class SendService < ApplicationService::Base
+class MinimalService < ApplicationService::Base
   stage { make :something }
   
   private
@@ -85,10 +107,10 @@ end
 
 #### Isolated usage
 
-With this approach, all input attributes are available only from `inputs`.
+With this approach, all input attributes are available only from `inputs`. This is default behaviour.
 
 ```ruby
-class UserService::Accept < ApplicationService::Base
+class UsersService::Accept < ApplicationService::Base
   input :user, type: User
   
   stage { make :accept! }
@@ -106,7 +128,7 @@ end
 With this approach, all input attributes are available from `inputs` as well as directly from the context.
 
 ```ruby
-class UserService::Accept < ApplicationService::Base
+class UsersService::Accept < ApplicationService::Base
   input :user, type: User, internal: true
   
   stage { make :accept! }
@@ -119,6 +141,59 @@ class UserService::Accept < ApplicationService::Base
 end
 ```
 
+#### Optional inputs
+
+By default, all inputs are required. To make an input optional, specify `false` in the `required` option.
+
+```ruby
+class UsersService::Create < ApplicationService::Base
+  input :first_name, type: String, internal: true
+  input :middle_name, type: String, required: false
+  input :last_name, type: String, internal: true
+
+  # ...
+end
+```
+
+#### An array of specific values
+
+```ruby
+class PymentsService::Send < ApplicationService::Base
+  input :invoice_numbers, type: String, array: true
+
+  # ...
+end
+```
+
+#### Inclusion
+
+```ruby
+class EventService::Send < ApplicationService::Base
+  input :event_name, type: String, inclusion: %w[created rejected approved]
+
+  # ...
+end
+```
+
+#### Must
+
+Sometimes there are cases that require the implementation of a specific input attribute check. In such cases `must` can help.
+
+```ruby
+class PymentsService::Send < ApplicationService::Base
+  input :invoice_numbers,
+        type: String,
+        array: true,
+        must: {
+          be_6_characters: {
+            is: ->(value:) { value.all? { |id| id.size == 6 } }
+          }
+        }
+
+  # ...
+end
+```
+
 ### Output attributes
 
 ```ruby

data/lib/servactory/context/dsl.rb

@@ -35,11 +35,16 @@ module Servactory
 
         attr_reader :context_store
 
-        def assign_data_with(arguments)
-          input_arguments_workbench.assign(context: context_store.context, arguments: arguments)  # 1
-          internal_arguments_workbench.assign(context: context_store.context)                     # 2
-          output_arguments_workbench.assign(context: context_store.context)                       # 3
-          stage_handyman&.assign(context: context_store.context)                                  # 4
+        def assign_data_with(arguments) # rubocop:disable Metrics/AbcSize
+          input_arguments_workbench.assign(
+            context: context_store.context,
+            arguments: arguments,
+            collection_of_input_options: collection_of_input_options
+          )
+
+          internal_arguments_workbench.assign(context: context_store.context)
+          output_arguments_workbench.assign(context: context_store.context)
+          stage_handyman&.assign(context: context_store.context)
         end
 
         def prepare_data

data/lib/servactory/input_arguments/checks/inclusion.rb

@@ -5,7 +5,7 @@ module Servactory
     module Checks
       class Inclusion < Base
         DEFAULT_MESSAGE = lambda do |service_class_name:, input:|
-          "[#{service_class_name}] Wrong value in `#{input.name}`, must be one of `#{input.inclusion}`"
+          "[#{service_class_name}] Wrong value in `#{input.name}`, must be one of `#{input.inclusion[:in]}`"
         end
 
         private_constant :DEFAULT_MESSAGE
@@ -31,7 +31,7 @@ module Servactory
         end
 
         def check
-          return if @input.inclusion.include?(@value)
+          return if @input.inclusion[:in].include?(@value)
 
           add_error(
             DEFAULT_MESSAGE,

data/lib/servactory/input_arguments/checks/must.rb

@@ -57,10 +57,12 @@ module Servactory
           return if check.call(value: @value)
 
           message.presence || DEFAULT_MESSAGE
-        rescue StandardError => _e
+        rescue StandardError => e
           message_text =
             "[#{@context.class.name}] Syntax error inside `#{code}` of `#{@input.name}` input"
 
+          puts "#{message_text}: #{e}"
+
           add_error(
             message_text,
             service_class_name: @context.class.name,

data/lib/servactory/input_arguments/dsl.rb

@@ -11,13 +11,21 @@ module Servactory
         private
 
         def input(name, **options)
-          collection_of_input_arguments << InputArgument.new(name, **options)
+          collection_of_input_arguments << InputArgument.new(
+            name,
+            collection_of_options: collection_of_input_options,
+            **options
+          )
         end
 
         def collection_of_input_arguments
           @collection_of_input_arguments ||= Collection.new
         end
 
+        def collection_of_input_options
+          @collection_of_input_options ||= OptionsCollection.new
+        end
+
         def input_arguments_workbench
           @input_arguments_workbench ||= Workbench.work_with(collection_of_input_arguments)
         end

data/lib/servactory/input_arguments/input_argument.rb

@@ -2,86 +2,187 @@
 
 module Servactory
   module InputArguments
-    class InputArgument
+    class InputArgument # rubocop:disable Metrics/ClassLength
       ARRAY_DEFAULT_VALUE = ->(is: false, message: nil) { { is: is, message: message } }
 
       attr_reader :name,
-                  :types,
-                  :inclusion,
-                  :must,
-                  :array,
-                  :required,
-                  :internal,
-                  :default
-
-      def initialize(name, type:, **options)
+                  :collection_of_options,
+                  :types
+
+      def initialize(name, collection_of_options:, type:, **options)
         @name = name
+        @collection_of_options = collection_of_options
         @types = Array(type)
 
-        @inclusion = options.fetch(:inclusion, nil)
-        @must = options.fetch(:must, nil)
-        @array = prepare_advanced_for(options.fetch(:array, ARRAY_DEFAULT_VALUE.call))
-        @required = options.fetch(:required, true)
-        @internal = options.fetch(:internal, false)
-        @default = options.fetch(:default, nil)
-      end
+        add_basic_options_with(options)
 
-      def options_for_checks
-        {
-          types: types,
-          inclusion: inclusion,
-          must: must,
-          required: required,
-          # internal: internal,
-          default: default
-        }
-      end
+        @collection_of_options.each do |option|
+          self.class.attr_reader(:"#{option.name}")
 
-      def prepare_advanced_for(value)
-        if value.is_a?(Hash)
-          ARRAY_DEFAULT_VALUE.call(
-            is: value.fetch(:is, false),
-            message: value.fetch(:message, nil)
-          )
-        else
-          ARRAY_DEFAULT_VALUE.call(is: value)
+          instance_variable_set(:"@#{option.name}", option.value)
         end
       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?
+      def add_basic_options_with(options)
+        # Check Class: Servactory::InputArguments::Checks::Required
+        add_required_option_with(options)
 
-        nil
+        # Check Class: Servactory::InputArguments::Checks::Type
+        add_array_option_with(options)
+        add_default_option_with(options)
+
+        # Check Class: Servactory::InputArguments::Checks::Inclusion
+        add_inclusion_option_with(options)
+
+        # Check Class: Servactory::InputArguments::Checks::Must
+        add_must_option_with(options)
+
+        # Check Class: nil
+        add_internal_option_with(options)
+      end
+
+      def add_required_option_with(options) # rubocop:disable Metrics/MethodLength
+        collection_of_options << Option.new(
+          name: :required,
+          input: self,
+          check_class: Servactory::InputArguments::Checks::Required,
+          define_input_methods: lambda do
+            <<-RUBY
+              def required?
+                Servactory::Utils.boolean?(required[:is])
+              end
+
+              def optional?
+                !required?
+              end
+            RUBY
+          end,
+          define_conflicts: lambda do
+            <<-RUBY
+              return :required_vs_default if required? && default_value_present?
+            RUBY
+          end,
+          need_for_checks: true,
+          value_key: :is,
+          value_fallback: true,
+          **options
+        )
       end
 
-      def inclusion_present?
-        inclusion.is_a?(Array) && inclusion.present?
+      def add_array_option_with(options) # rubocop:disable Metrics/MethodLength
+        collection_of_options << Option.new(
+          name: :array,
+          input: self,
+          check_class: Servactory::InputArguments::Checks::Type,
+          define_input_methods: lambda do
+            <<-RUBY
+              def array?
+                Servactory::Utils.boolean?(array[:is])
+              end
+            RUBY
+          end,
+          define_conflicts: lambda do
+            <<-RUBY
+              return :array_vs_array if array? && types.include?(Array)
+              return :array_vs_inclusion if array? && inclusion_present?
+            RUBY
+          end,
+          need_for_checks: false,
+          value_key: :is,
+          value_fallback: false,
+          **options
+        )
       end
 
-      def must_present?
-        must.present?
+      def add_default_option_with(options) # rubocop:disable Metrics/MethodLength
+        collection_of_options << Option.new(
+          name: :default,
+          input: self,
+          check_class: Servactory::InputArguments::Checks::Type,
+          define_input_methods: lambda do
+            <<-RUBY
+              def default_value_present?
+                !default.nil?
+              end
+            RUBY
+          end,
+          need_for_checks: true,
+          value_fallback: nil,
+          with_advanced_mode: false,
+          **options
+        )
       end
 
-      def array?
-        Servactory::Utils.boolean?(array[:is])
+      def add_inclusion_option_with(options) # rubocop:disable Metrics/MethodLength
+        collection_of_options << Option.new(
+          name: :inclusion,
+          input: self,
+          check_class: Servactory::InputArguments::Checks::Inclusion,
+          define_input_methods: lambda do
+            <<-RUBY
+              def inclusion_present?
+                inclusion[:in].is_a?(Array) && inclusion[:in].present?
+              end
+            RUBY
+          end,
+          need_for_checks: true,
+          value_key: :in,
+          value_fallback: nil,
+          **options
+        )
       end
 
-      def required?
-        Servactory::Utils.boolean?(required)
+      def add_must_option_with(options) # rubocop:disable Metrics/MethodLength
+        collection_of_options << Option.new(
+          name: :must,
+          input: self,
+          check_class: Servactory::InputArguments::Checks::Must,
+          define_input_methods: lambda do
+            <<-RUBY
+              def must_present?
+                must.present?
+              end
+            RUBY
+          end,
+          need_for_checks: true,
+          value_key: :is,
+          value_fallback: nil,
+          with_advanced_mode: false,
+          **options
+        )
       end
 
-      def optional?
-        !required?
+      def add_internal_option_with(options) # rubocop:disable Metrics/MethodLength
+        collection_of_options << Option.new(
+          name: :internal,
+          input: self,
+          define_input_methods: lambda do
+            <<-RUBY
+              def internal?
+                Servactory::Utils.boolean?(internal[:is])
+              end
+            RUBY
+          end,
+          need_for_checks: false,
+          check_class: nil,
+          value_key: :is,
+          value_fallback: false,
+          **options
+        )
       end
 
-      def internal?
-        Servactory::Utils.boolean?(internal)
+      def options_for_checks
+        {
+          types: types
+        }.merge(
+          collection_of_options.options_for_checks
+        )
       end
 
-      def default_value_present?
-        !default.nil?
+      def conflict_code
+        instance_eval(collection_of_options.defined_conflicts)
+
+        nil
       end
 
       def with_conflicts?

data/lib/servactory/input_arguments/option.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Servactory
+  module InputArguments
+    class Option
+      DEFAULT_VALUE = ->(key:, value:, message: nil) { { key => value, message: message } }
+
+      private_constant :DEFAULT_VALUE
+
+      attr_reader :name,
+                  :check_class,
+                  :define_conflicts,
+                  :need_for_checks,
+                  :value_key,
+                  :value
+
+      def initialize(
+        name:,
+        input:,
+        check_class:,
+        need_for_checks:,
+        value_fallback:,
+        value_key: nil,
+        define_input_methods: nil,
+        define_conflicts: nil,
+        with_advanced_mode: true,
+        **options
+      ) # do
+        @name = name.to_sym
+        @check_class = check_class
+        @define_conflicts = define_conflicts
+        @need_for_checks = need_for_checks
+        @value_key = value_key
+
+        @value = prepare_value_for(options, value_fallback: value_fallback, with_advanced_mode: with_advanced_mode)
+
+        input.instance_eval(define_input_methods.call) if define_input_methods.present?
+      end
+
+      def need_for_checks?
+        need_for_checks
+      end
+
+      private
+
+      def prepare_value_for(options, value_fallback:, with_advanced_mode:)
+        return options.fetch(@name, value_fallback) unless with_advanced_mode
+
+        prepare_advanced_for(
+          value: options.fetch(@name, DEFAULT_VALUE.call(key: value_key, value: value_fallback)),
+          value_fallback: value_fallback
+        )
+      end
+
+      def prepare_advanced_for(value:, value_fallback:)
+        if value.is_a?(Hash)
+          DEFAULT_VALUE.call(
+            key: value_key,
+            value: value.fetch(value_key, value_fallback),
+            message: value.fetch(:message, nil)
+          )
+        else
+          DEFAULT_VALUE.call(key: value_key, value: value)
+        end
+      end
+    end
+  end
+end

data/lib/servactory/input_arguments/options_collection.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Servactory
+  module InputArguments
+    class OptionsCollection
+      # NOTE: http://words.steveklabnik.com/beware-subclassing-ruby-core-classes
+      extend Forwardable
+      def_delegators :@collection, :<<, :each, :select, :map
+
+      def initialize(*)
+        @collection = []
+      end
+
+      def check_classes
+        select { |option| option.check_class.present? }.map(&:check_class).uniq
+      end
+
+      def options_for_checks
+        select(&:need_for_checks?).to_h do |option|
+          value = if option.value.is_a?(Hash)
+                    option.value.key?(:is) ? option.value.fetch(:is) : option.value
+                  else
+                    option.value
+                  end
+
+          [option.name, value]
+        end
+      end
+
+      def defined_conflicts
+        map { |option| option.define_conflicts&.call }.reject(&:blank?).uniq.join
+      end
+    end
+  end
+end

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

@@ -8,10 +8,11 @@ module Servactory
           new(...).check!
         end
 
-        def initialize(context, incoming_arguments, collection_of_input_arguments)
+        def initialize(context, incoming_arguments, collection_of_input_arguments, collection_of_input_options)
           @context = context
           @incoming_arguments = incoming_arguments
           @collection_of_input_arguments = collection_of_input_arguments
+          @collection_of_input_options = collection_of_input_options
 
           @errors = []
         end
@@ -58,20 +59,15 @@ module Servactory
         ########################################################################
 
         def check_classes
-          [
-            Servactory::InputArguments::Checks::Required,
-            Servactory::InputArguments::Checks::Type,
-            Servactory::InputArguments::Checks::Inclusion,
-            Servactory::InputArguments::Checks::Must
-          ]
+          @collection_of_input_options.check_classes
         end
 
         ########################################################################
 
         def raise_errors
-          return if @errors.empty?
+          return if (tmp_errors = @errors.reject(&:blank?).uniq).empty?
 
-          raise Servactory.configuration.input_argument_error_class, @errors.first
+          raise Servactory.configuration.input_argument_error_class, tmp_errors.first
         end
       end
     end

data/lib/servactory/input_arguments/workbench.rb

@@ -11,9 +11,10 @@ module Servactory
         @collection_of_input_arguments = collection_of_input_arguments
       end
 
-      def assign(context:, arguments:)
+      def assign(context:, arguments:, collection_of_input_options:)
         @context = context
         @incoming_arguments = arguments
+        @collection_of_input_options = collection_of_input_options
       end
 
       def find_unnecessary!
@@ -29,12 +30,14 @@ module Servactory
       end
 
       def check!
-        Tools::Check.check!(context, @incoming_arguments, collection_of_input_arguments)
+        Tools::Check.check!(context, @incoming_arguments, collection_of_input_arguments, collection_of_input_options)
       end
 
       private
 
-      attr_reader :context, :collection_of_input_arguments
+      attr_reader :context,
+                  :collection_of_input_arguments,
+                  :collection_of_input_options
     end
   end
 end

data/lib/servactory/version.rb

@@ -3,7 +3,7 @@
 module Servactory
   module VERSION
     MAJOR = 1
-    MINOR = 3
+    MINOR = 4
     PATCH = 0
 
     STRING = [MAJOR, MINOR, PATCH].join(".")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: servactory
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.4.0
 platform: ruby
 authors:
 - Anton Sokolov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-06 00:00:00.000000000 Z
+date: 2023-05-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: zeitwerk
@@ -178,6 +178,8 @@ files:
 - lib/servactory/input_arguments/collection.rb
 - lib/servactory/input_arguments/dsl.rb
 - lib/servactory/input_arguments/input_argument.rb
+- lib/servactory/input_arguments/option.rb
+- lib/servactory/input_arguments/options_collection.rb
 - lib/servactory/input_arguments/tools/check.rb
 - lib/servactory/input_arguments/tools/find_unnecessary.rb
 - lib/servactory/input_arguments/tools/prepare.rb