convenient_service 0.22.0 → 0.24.0

data/lib/convenient_service/service/plugins/{can_have_step_aware_enumerables/entities/step_aware_enumerables → can_have_service_aware_enumerables/entities/service_aware_enumerables}/base.rb

@@ -8,9 +8,9 @@
 module ConvenientService
   module Service
     module Plugins
-      module CanHaveStepAwareEnumerables
+      module CanHaveServiceAwareEnumerables
         module Entities
-          module StepAwareEnumerables
+          module ServiceAwareEnumerables
             class Base
               include Support::AbstractMethod
 
@@ -67,10 +67,10 @@ module ConvenientService
               #     def initialize(object:, organizer:, propagated_result:)
               #       if object.is_a?(::Enumerator)
               #         mapping = {
-              #           ::Enumerator => Entities::StepAwareEnumerables::Enumerator,
-              #           ::Enumerator::Lazy => Entities::StepAwareEnumerables::LazyEnumerator,
-              #           ::Enumerator::Chain => Entities::StepAwareEnumerables::ChainEnumerator,
-              #            ::Enumerator::ArithmeticSequence => Entities::StepAwareEnumerables::ArithmeticSequenceEnumerator
+              #           ::Enumerator => Entities::ServiceAwareEnumerables::Enumerator,
+              #           ::Enumerator::Lazy => Entities::ServiceAwareEnumerables::LazyEnumerator,
+              #           ::Enumerator::Chain => Entities::ServiceAwareEnumerables::ChainEnumerator,
+              #            ::Enumerator::ArithmeticSequence => Entities::ServiceAwareEnumerables::ArithmeticSequenceEnumerator
               #         }
               #
               #         raise "No mapping for class `#{object.class}`." unless mapping[object.class]
@@ -123,259 +123,247 @@ module ConvenientService
               ##
               # @param iterator_arguments [ConvenientService::Support::Arguments]
               # @param iterator_block [Proc]
-              # @return [ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Object]
+              # @return [ConvenientService::Service::Plugins::CanHaveServiceAwareEnumerables::Entities::ServiceAwareEnumerables::Object]
               #
               def with_processing_return_value_as_object(iterator_arguments = Support::Arguments.null_arguments, &iterator_block)
-                with_processing_return_value(iterator_arguments, iterator_block) { |value, propagated_result| step_aware_object_from(value, propagated_result) }
+                with_processing_return_value(iterator_arguments, iterator_block) { |value, propagated_result| service_aware_object_from(value, propagated_result) }
               end
 
               ##
               # @param iterator_arguments [ConvenientService::Support::Arguments]
               # @param iterator_block [Proc]
-              # @return [ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Object]
+              # @return [ConvenientService::Service::Plugins::CanHaveServiceAwareEnumerables::Entities::ServiceAwareEnumerables::Object]
               #
               def with_processing_return_value_as_object_or_nil(iterator_arguments = Support::Arguments.null_arguments, &iterator_block)
-                with_processing_return_value(iterator_arguments, iterator_block) { |value, propagated_result| step_aware_object_or_nil_from(value, propagated_result) }
+                with_processing_return_value(iterator_arguments, iterator_block) { |value, propagated_result| service_aware_object_or_nil_from(value, propagated_result) }
               end
 
               ##
               # @param iterator_arguments [ConvenientService::Support::Arguments]
               # @param iterator_block [Proc]
-              # @return [ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Object]
+              # @return [ConvenientService::Service::Plugins::CanHaveServiceAwareEnumerables::Entities::ServiceAwareEnumerables::Object]
               #
               def with_processing_return_value_as_boolean(iterator_arguments = Support::Arguments.null_arguments, &iterator_block)
-                with_processing_return_value(iterator_arguments, iterator_block) { |value, propagated_result| step_aware_boolean_from(value, propagated_result) }
+                with_processing_return_value(iterator_arguments, iterator_block) { |value, propagated_result| service_aware_boolean_from(value, propagated_result) }
               end
 
               ##
               # @param iterator_arguments [ConvenientService::Support::Arguments]
               # @param iterator_block [Proc]
-              # @return [ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Object]
+              # @return [ConvenientService::Service::Plugins::CanHaveServiceAwareEnumerables::Entities::ServiceAwareEnumerables::Object]
               #
               def with_processing_return_value_as_enumerable(iterator_arguments = Support::Arguments.null_arguments, &iterator_block)
-                with_processing_return_value(iterator_arguments, iterator_block) { |value, propagated_result| step_aware_enumerable_from(value, propagated_result) }
+                with_processing_return_value(iterator_arguments, iterator_block) { |value, propagated_result| service_aware_enumerable_from(value, propagated_result) }
               end
 
               ##
               # @param iterator_arguments [ConvenientService::Support::Arguments]
               # @param iterator_block [Proc]
-              # @return [ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Object]
+              # @return [ConvenientService::Service::Plugins::CanHaveServiceAwareEnumerables::Entities::ServiceAwareEnumerables::Object]
               #
               def with_processing_return_value_as_array(iterator_arguments = Support::Arguments.null_arguments, &iterator_block)
-                with_processing_return_value(iterator_arguments, iterator_block) { |value, propagated_result| step_aware_array_from(value, propagated_result) }
+                with_processing_return_value(iterator_arguments, iterator_block) { |value, propagated_result| service_aware_array_from(value, propagated_result) }
               end
 
               ##
               # @param iterator_arguments [ConvenientService::Support::Arguments]
               # @param iterator_block [Proc]
-              # @return [ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Object]
+              # @return [ConvenientService::Service::Plugins::CanHaveServiceAwareEnumerables::Entities::ServiceAwareEnumerables::Object]
               #
               def with_processing_return_value_as_hash(iterator_arguments = Support::Arguments.null_arguments, &iterator_block)
-                with_processing_return_value(iterator_arguments, iterator_block) { |value, propagated_result| step_aware_hash_from(value, propagated_result) }
+                with_processing_return_value(iterator_arguments, iterator_block) { |value, propagated_result| service_aware_hash_from(value, propagated_result) }
               end
 
               ##
               # @param iterator_arguments [ConvenientService::Support::Arguments]
               # @param iterator_block [Proc]
-              # @return [ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Object]
+              # @return [ConvenientService::Service::Plugins::CanHaveServiceAwareEnumerables::Entities::ServiceAwareEnumerables::Object]
               #
               def with_processing_return_value_as_set(iterator_arguments = Support::Arguments.null_arguments, &iterator_block)
-                with_processing_return_value(iterator_arguments, iterator_block) { |value, propagated_result| step_aware_set_from(value, propagated_result) }
+                with_processing_return_value(iterator_arguments, iterator_block) { |value, propagated_result| service_aware_set_from(value, propagated_result) }
               end
 
               ##
               # @param iterator_arguments [ConvenientService::Support::Arguments]
               # @param iterator_block [Proc]
-              # @return [ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Enumerator]
+              # @return [ConvenientService::Service::Plugins::CanHaveServiceAwareEnumerables::Entities::ServiceAwareEnumerables::Enumerator]
               #
               def with_processing_return_value_as_enumerator(iterator_arguments = Support::Arguments.null_arguments, &iterator_block)
-                with_processing_return_value(iterator_arguments, iterator_block) { |value, propagated_result| step_aware_enumerator_from(value, propagated_result) }
+                with_processing_return_value(iterator_arguments, iterator_block) { |value, propagated_result| service_aware_enumerator_from(value, propagated_result) }
               end
 
               ##
-              # @return [ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Enumerator]
+              # @return [ConvenientService::Service::Plugins::CanHaveServiceAwareEnumerables::Entities::ServiceAwareEnumerables::Enumerator]
               #
               alias_method :with_processing_return_value_as_enumerator_generator, :with_processing_return_value_as_enumerator
 
               ##
               # @param iterator_arguments [ConvenientService::Support::Arguments]
               # @param iterator_block [Proc]
-              # @return [ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::LazyEnumerator]
+              # @return [ConvenientService::Service::Plugins::CanHaveServiceAwareEnumerables::Entities::ServiceAwareEnumerables::LazyEnumerator]
               #
               def with_processing_return_value_as_lazy_enumerator(iterator_arguments = Support::Arguments.null_arguments, &iterator_block)
-                with_processing_return_value(iterator_arguments, iterator_block) { |value, propagated_result| step_aware_lazy_enumerator_from(value, propagated_result) }
+                with_processing_return_value(iterator_arguments, iterator_block) { |value, propagated_result| service_aware_lazy_enumerator_from(value, propagated_result) }
               end
 
               ##
               # @param iterator_arguments [ConvenientService::Support::Arguments]
               # @param iterator_block [Proc]
-              # @return [ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::ChainEnumerator]
+              # @return [ConvenientService::Service::Plugins::CanHaveServiceAwareEnumerables::Entities::ServiceAwareEnumerables::ChainEnumerator]
               #
               def with_processing_return_value_as_chain_enumerator(iterator_arguments = Support::Arguments.null_arguments, &iterator_block)
-                with_processing_return_value(iterator_arguments, iterator_block) { |value, propagated_result| step_aware_chain_enumerator_from(value, propagated_result) }
+                with_processing_return_value(iterator_arguments, iterator_block) { |value, propagated_result| service_aware_chain_enumerator_from(value, propagated_result) }
               end
 
               ##
               # @param iterator_arguments [ConvenientService::Support::Arguments]
               # @param iterator_block [Proc]
-              # @return [ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::ArithmeticSequenceEnumerator]
+              # @return [ConvenientService::Service::Plugins::CanHaveServiceAwareEnumerables::Entities::ServiceAwareEnumerables::ArithmeticSequenceEnumerator]
               #
               def with_processing_return_value_as_arithmetic_sequence_enumerator(iterator_arguments = Support::Arguments.null_arguments, &iterator_block)
-                with_processing_return_value(arguments, iterator_block) { |value, propagated_result| step_aware_arithmetic_sequence_enumerator_from(value, propagated_result) }
+                with_processing_return_value(arguments, iterator_block) { |value, propagated_result| service_aware_arithmetic_sequence_enumerator_from(value, propagated_result) }
               end
 
               ##
               # @param iteration_block [Proc, nil]
               # @return [Proc]
               #
-              def step_aware_iteration_block_from(iteration_block)
+              # @internal
+              #   NOTE: It may look very appealing to return data objects instead of hashes. For example:
+              #     # With hashes.
+              #     result =
+              #       service_aware_enumerable(users)
+              #         .map { |user| step ProcessUser, in: :user, out: [:attributes, :associations] }
+              #         .each { |values| p [values[:attributes], values[:associations]] }
+              #         .result(data_key: :items)
+              #
+              #     result.data[:items]
+              #     # => [{attributes: {}, associations: []}, {attributes: {}, associations: []}]
+              #
+              #     # With data objects.
+              #     result =
+              #       service_aware_enumerable(users)
+              #         .map { |user| step ProcessUser, in: :user, out: [:attributes, :associations] }
+              #         .each { |data| p [data.attributes, data.associations] }
+              #         .result(data_key: :items)
+              #
+              #     result.data[:items]
+              #     # => [<...Data attributes: {}, associations: []>, <...Data attributes: {}, associations: []>]
+              #
+              #     But:
+              #     - Is it OK to return nested data objects from results?
+              #     - If not, how can those nested data objects be efficiently converted into hashes only for the results (data may return arrays, hashes, sets, enumerators, arithmetic sequences, etc.)?
+              #
+              #     next data.one? ? data.values.first : result.create_data(data)
+              #
+              def service_aware_iteration_block_from(iteration_block)
                 return unless iteration_block
 
                 proc do |*args|
-                  value = iteration_block.call(*args)
-
-                  next value unless Plugins::CanHaveSteps.step?(value)
-
-                  if value.success?
-                    next true if value.outputs.none?
-
-                    ##
-                    # NOTE: It may look very appealing to return data objects instead of hashes. For example:
-                    #   # With hashes.
-                    #   result =
-                    #     step_aware_enumerable(users)
-                    #       .map { |user| step ProcessUser, in: :user, out: [:attributes, :associations] }
-                    #       .each { |values| p [values[:attributes], values[:associations]] }
-                    #       .result(data_key: :items)
-                    #
-                    #   result.data[:items]
-                    #   # => [{attributes: {}, associations: []}, {attributes: {}, associations: []}]
-                    #
-                    #   # With data objects.
-                    #   result =
-                    #     step_aware_enumerable(users)
-                    #       .map { |user| step ProcessUser, in: :user, out: [:attributes, :associations] }
-                    #       .each { |data| p [data.attributes, data.associations] }
-                    #       .result(data_key: :items)
-                    #
-                    #   result.data[:items]
-                    #   # => [<...Data attributes: {}, associations: []>, <...Data attributes: {}, associations: []>]
-                    #
-                    #   But:
-                    #   - Is it OK to return nested data objects from results?
-                    #   - If not, how can those nested data objects be efficiently converted into hashes only for the results (data may return arrays, hashes, sets, enumerators, arithmetic sequences, etc.)?
-                    #
-                    # next value.outputs.one? ? value.output_values.values.first : value.result.create_data(value.output_values)
-
-                    next value.outputs.one? ? value.output_values.values.first : value.output_values
-                  end
-
-                  if value.failure?
-                    next value.outputs.none? ? false : nil
-                  end
-
-                  throw :propagated_result, {propagated_result: value.result}
+                  service = iteration_block.call(*args)
+
+                  service.to_service_aware_iteration_block_value
                 end
               end
 
               ##
               # @param object [Object] Can be any type.
               # @param propagated_result [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result, nil]
-              # @return [ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Object]
+              # @return [ConvenientService::Service::Plugins::CanHaveServiceAwareEnumerables::Entities::ServiceAwareEnumerables::Object]
               #
-              def step_aware_object_from(object, propagated_result)
+              def service_aware_object_from(object, propagated_result)
                 # TODO: Cast.
-                Entities::StepAwareEnumerables::Object.new(object: object, organizer: organizer, propagated_result: propagated_result)
+                Entities::ServiceAwareEnumerables::Object.new(object: object, organizer: organizer, propagated_result: propagated_result)
               end
 
               ##
               # @param object [Object] Can be any type.
               # @param propagated_result [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result, nil]
-              # @return [ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Object]
+              # @return [ConvenientService::Service::Plugins::CanHaveServiceAwareEnumerables::Entities::ServiceAwareEnumerables::Object]
               #
-              def step_aware_object_or_nil_from(object, propagated_result)
-                Entities::StepAwareEnumerables::ObjectOrNil.new(object: object, organizer: organizer, propagated_result: propagated_result)
+              def service_aware_object_or_nil_from(object, propagated_result)
+                Entities::ServiceAwareEnumerables::ObjectOrNil.new(object: object, organizer: organizer, propagated_result: propagated_result)
               end
 
               ##
               # @param boolean [Boolean].
               # @param propagated_result [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result, nil]
-              # @return [ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Object]
+              # @return [ConvenientService::Service::Plugins::CanHaveServiceAwareEnumerables::Entities::ServiceAwareEnumerables::Object]
               #
-              def step_aware_boolean_from(boolean, propagated_result)
-                Entities::StepAwareEnumerables::Boolean.new(object: boolean, organizer: organizer, propagated_result: propagated_result)
+              def service_aware_boolean_from(boolean, propagated_result)
+                Entities::ServiceAwareEnumerables::Boolean.new(object: boolean, organizer: organizer, propagated_result: propagated_result)
               end
 
               ##
               # @param enumerable [Enumerable]
               # @param propagated_result [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result, nil]
-              # @return [ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Enumerable]
+              # @return [ConvenientService::Service::Plugins::CanHaveServiceAwareEnumerables::Entities::ServiceAwareEnumerables::Enumerable]
               #
-              def step_aware_enumerable_from(enumerable, propagated_result)
-                Entities::StepAwareEnumerables::Enumerable.new(object: enumerable, organizer: organizer, propagated_result: propagated_result)
+              def service_aware_enumerable_from(enumerable, propagated_result)
+                Entities::ServiceAwareEnumerables::Enumerable.new(object: enumerable, organizer: organizer, propagated_result: propagated_result)
               end
 
               ##
               # @param array [Array]
               # @param propagated_result [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result, nil]
-              # @return [ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Enumerable]
+              # @return [ConvenientService::Service::Plugins::CanHaveServiceAwareEnumerables::Entities::ServiceAwareEnumerables::Enumerable]
               #
-              def step_aware_array_from(array, propagated_result)
-                Entities::StepAwareEnumerables::Array.new(object: array, organizer: organizer, propagated_result: propagated_result)
+              def service_aware_array_from(array, propagated_result)
+                Entities::ServiceAwareEnumerables::Array.new(object: array, organizer: organizer, propagated_result: propagated_result)
               end
 
               ##
               # @param hash [Hash]
               # @param propagated_result [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result, nil]
-              # @return [ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Enumerable]
+              # @return [ConvenientService::Service::Plugins::CanHaveServiceAwareEnumerables::Entities::ServiceAwareEnumerables::Enumerable]
               #
-              def step_aware_hash_from(hash, propagated_result)
-                Entities::StepAwareEnumerables::Hash.new(object: hash, organizer: organizer, propagated_result: propagated_result)
+              def service_aware_hash_from(hash, propagated_result)
+                Entities::ServiceAwareEnumerables::Hash.new(object: hash, organizer: organizer, propagated_result: propagated_result)
               end
 
               ##
               # @param set [Set]
               # @param propagated_result [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result, nil]
-              # @return [ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Enumerable]
+              # @return [ConvenientService::Service::Plugins::CanHaveServiceAwareEnumerables::Entities::ServiceAwareEnumerables::Enumerable]
               #
-              def step_aware_set_from(set, propagated_result)
-                Entities::StepAwareEnumerables::Set.new(object: set, organizer: organizer, propagated_result: propagated_result)
+              def service_aware_set_from(set, propagated_result)
+                Entities::ServiceAwareEnumerables::Set.new(object: set, organizer: organizer, propagated_result: propagated_result)
               end
 
               ##
               # @param enumerator [Enumerator]
               # @param propagated_result [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result, nil]
-              # @return [ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Enumerator]
+              # @return [ConvenientService::Service::Plugins::CanHaveServiceAwareEnumerables::Entities::ServiceAwareEnumerables::Enumerator]
               #
-              def step_aware_enumerator_from(enumerator, propagated_result)
-                Entities::StepAwareEnumerables::Enumerator.new(object: enumerator, organizer: organizer, propagated_result: propagated_result)
+              def service_aware_enumerator_from(enumerator, propagated_result)
+                Entities::ServiceAwareEnumerables::Enumerator.new(object: enumerator, organizer: organizer, propagated_result: propagated_result)
               end
 
               ##
               # @param lazy_enumerator [Enumerator]
               # @param propagated_result [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result, nil]
-              # @return [ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Enumerator]
+              # @return [ConvenientService::Service::Plugins::CanHaveServiceAwareEnumerables::Entities::ServiceAwareEnumerables::Enumerator]
               #
-              def step_aware_lazy_enumerator_from(lazy_enumerator, propagated_result)
-                Entities::StepAwareEnumerables::LazyEnumerator.new(object: lazy_enumerator, organizer: organizer, propagated_result: propagated_result)
+              def service_aware_lazy_enumerator_from(lazy_enumerator, propagated_result)
+                Entities::ServiceAwareEnumerables::LazyEnumerator.new(object: lazy_enumerator, organizer: organizer, propagated_result: propagated_result)
               end
 
               ##
               # @param chain_enumerator [Enumerator::Chain]
               # @param propagated_result [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result, nil]
-              # @return [ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::ChainEnumerator]
+              # @return [ConvenientService::Service::Plugins::CanHaveServiceAwareEnumerables::Entities::ServiceAwareEnumerables::ChainEnumerator]
               #
-              def step_aware_chain_enumerator_from(chain_enumerator, propagated_result)
-                Entities::StepAwareEnumerables::ChainEnumerator.new(object: chain_enumerator, organizer: organizer, propagated_result: propagated_result)
+              def service_aware_chain_enumerator_from(chain_enumerator, propagated_result)
+                Entities::ServiceAwareEnumerables::ChainEnumerator.new(object: chain_enumerator, organizer: organizer, propagated_result: propagated_result)
               end
 
               ##
               # @param arithmetic_sequence_enumerator [Enumerator::ArithmeticSequence]
               # @param propagated_result [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result, nil]
-              # @return [ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::ArithmeticSequence::Enumerator]
+              # @return [ConvenientService::Service::Plugins::CanHaveServiceAwareEnumerables::Entities::ServiceAwareEnumerables::ArithmeticSequence::Enumerator]
               #
-              def step_aware_arithmetic_sequence_enumerator_from(arithmetic_sequence_enumerator, propagated_result)
-                Entities::StepAwareEnumerables::ArithmeticSequenceEnumerator.new(object: arithmetic_sequence_enumerator, organizer: organizer, propagated_result: propagated_result)
+              def service_aware_arithmetic_sequence_enumerator_from(arithmetic_sequence_enumerator, propagated_result)
+                Entities::ServiceAwareEnumerables::ArithmeticSequenceEnumerator.new(object: arithmetic_sequence_enumerator, organizer: organizer, propagated_result: propagated_result)
               end
 
               ##
@@ -401,16 +389,16 @@ module ConvenientService
 
               ##
               # @param object [Object] Can be any type.
-              # @return [ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base]
+              # @return [ConvenientService::Service::Plugins::CanHaveServiceAwareEnumerables::Entities::ServiceAwareEnumerables::Base]
               #
-              def cast_step_aware_enumerable(object)
-                Commands::CastStepAwareEnumerable.call(object: object, organizer: organizer, propagated_result: propagated_result)
+              def cast_service_aware_enumerable(object)
+                Commands::CastServiceAwareEnumerable.call(object: object, organizer: organizer, propagated_result: propagated_result)
               end
 
               ##
               # @param value [Symbol, String, Proc, nil]
               # @return [Proc]
-              # @raise [ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Exceptions::InvalidEvaluateByValue]
+              # @raise [ConvenientService::Service::Plugins::CanHaveServiceAwareEnumerables::Exceptions::InvalidEvaluateByValue]
               #
               def cast_evaluate_by_block(value)
                 return proc { |enumerable| enumerable.public_send(value) } if value.instance_of?(::Symbol)
@@ -446,7 +434,7 @@ module ConvenientService
               # @param iterator_arguments [ConvenientService::Support::Arguments]
               # @param iterator_block [Proc]
               # @param with_processing_return_value_block [Proc]
-              # @return [ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Object]
+              # @return [ConvenientService::Service::Plugins::CanHaveServiceAwareEnumerables::Entities::ServiceAwareEnumerables::Object]
               #
               # @internal
               #   NOTE: `catch` is used to support lazy enumerators, `chunk`, and `chunk_while`.
@@ -454,7 +442,7 @@ module ConvenientService
               def with_processing_return_value(iterator_arguments, iterator_block, &with_processing_return_value_block)
                 return yield(Support::UNDEFINED, propagated_result) if propagated_result
 
-                response = catch(:propagated_result) { {object: iterator_block.call(*iterator_arguments.args, **iterator_arguments.kwargs, &step_aware_iteration_block_from(iterator_arguments.block))} }
+                response = catch(:propagated_result) { {object: iterator_block.call(*iterator_arguments.args, **iterator_arguments.kwargs, &iterator_arguments.block)} }
 
                 return yield(Support::UNDEFINED, response[:propagated_result]) if response.has_key?(:propagated_result)
 

data/lib/convenient_service/service/plugins/{can_have_step_aware_enumerables/entities/step_aware_enumerables → can_have_service_aware_enumerables/entities/service_aware_enumerables}/boolean.rb

@@ -8,10 +8,10 @@
 module ConvenientService
   module Service
     module Plugins
-      module CanHaveStepAwareEnumerables
+      module CanHaveServiceAwareEnumerables
         module Entities
-          module StepAwareEnumerables
-            class Boolean < Entities::StepAwareEnumerables::Object
+          module ServiceAwareEnumerables
+            class Boolean < Entities::ServiceAwareEnumerables::Object
               ##
               # @api private
               #

data/lib/convenient_service/service/plugins/{can_have_step_aware_enumerables/entities/step_aware_enumerables → can_have_service_aware_enumerables/entities/service_aware_enumerables}/chain_enumerator.rb

@@ -8,10 +8,10 @@
 module ConvenientService
   module Service
     module Plugins
-      module CanHaveStepAwareEnumerables
+      module CanHaveServiceAwareEnumerables
         module Entities
-          module StepAwareEnumerables
-            class ChainEnumerator < Entities::StepAwareEnumerables::Enumerator
+          module ServiceAwareEnumerables
+            class ChainEnumerator < Entities::ServiceAwareEnumerables::Enumerator
               ##
               # @api private
               #
@@ -23,12 +23,12 @@ module ConvenientService
               # @api public
               #
               # @param iteration_block [Proc, nil]
-              # @return [ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Enumerator, ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::ChainEnumerator]
+              # @return [ConvenientService::Service::Plugins::CanHaveServiceAwareEnumerables::Entities::ServiceAwareEnumerables::Enumerator, ConvenientService::Service::Plugins::CanHaveServiceAwareEnumerables::Entities::ServiceAwareEnumerables::ChainEnumerator]
               #
               def each(&iteration_block)
                 if iteration_block
-                  with_processing_return_value_as_chain_enumerator(arguments(&iteration_block)) do |&step_aware_iteration_block|
-                    chain_enumerator.each(&step_aware_iteration_block)
+                  with_processing_return_value_as_chain_enumerator(arguments(&iteration_block)) do |&service_aware_iteration_block|
+                    chain_enumerator.each(&service_aware_iteration_block)
                   end
                 else
                   with_processing_return_value_as_enumerator do
@@ -42,12 +42,12 @@ module ConvenientService
               #
               # @param n [Integer]
               # @param iteration_block [Proc, nil]
-              # @return [ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Enumerator, ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::ChainEnumerator]
+              # @return [ConvenientService::Service::Plugins::CanHaveServiceAwareEnumerables::Entities::ServiceAwareEnumerables::Enumerator, ConvenientService::Service::Plugins::CanHaveServiceAwareEnumerables::Entities::ServiceAwareEnumerables::ChainEnumerator]
               #
               def each_cons(n, &iteration_block)
                 if iteration_block
-                  with_processing_return_value_as_chain_enumerator(arguments(n, &iteration_block)) do |n, &step_aware_iteration_block|
-                    chain_enumerator.each_cons(n, &step_aware_iteration_block)
+                  with_processing_return_value_as_chain_enumerator(arguments(n, &iteration_block)) do |n, &service_aware_iteration_block|
+                    chain_enumerator.each_cons(n, &service_aware_iteration_block)
                   end
                 else
                   with_processing_return_value_as_enumerator(arguments(n)) do |n|
@@ -60,12 +60,12 @@ module ConvenientService
               # @api public
               #
               # @param iteration_block [Proc, nil]
-              # @return [ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Enumerator, ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::ChainEnumerator]
+              # @return [ConvenientService::Service::Plugins::CanHaveServiceAwareEnumerables::Entities::ServiceAwareEnumerables::Enumerator, ConvenientService::Service::Plugins::CanHaveServiceAwareEnumerables::Entities::ServiceAwareEnumerables::ChainEnumerator]
               #
               def each_entry(&iteration_block)
                 if iteration_block
-                  with_processing_return_value_as_chain_enumerator(arguments(&iteration_block)) do |&step_aware_iteration_block|
-                    chain_enumerator.each_entry(&step_aware_iteration_block)
+                  with_processing_return_value_as_chain_enumerator(arguments(&iteration_block)) do |&service_aware_iteration_block|
+                    chain_enumerator.each_entry(&service_aware_iteration_block)
                   end
                 else
                   with_processing_return_value_as_enumerator do
@@ -79,12 +79,12 @@ module ConvenientService
               #
               # @param n [Integer]
               # @param iteration_block [Proc, nil]
-              # @return [ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Enumerator, ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::ChainEnumerator]
+              # @return [ConvenientService::Service::Plugins::CanHaveServiceAwareEnumerables::Entities::ServiceAwareEnumerables::Enumerator, ConvenientService::Service::Plugins::CanHaveServiceAwareEnumerables::Entities::ServiceAwareEnumerables::ChainEnumerator]
               #
               def each_slice(n, &iteration_block)
                 if iteration_block
-                  with_processing_return_value_as_chain_enumerator(arguments(n, &iteration_block)) do |n, &step_aware_iteration_block|
-                    chain_enumerator.each_slice(n, &step_aware_iteration_block)
+                  with_processing_return_value_as_chain_enumerator(arguments(n, &iteration_block)) do |n, &service_aware_iteration_block|
+                    chain_enumerator.each_slice(n, &service_aware_iteration_block)
                   end
                 else
                   with_processing_return_value_as_enumerator(arguments(n)) do |n|
@@ -97,12 +97,12 @@ module ConvenientService
               # @api public
               #
               # @param iteration_block [Proc, nil]
-              # @return [ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Enumerator, ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::ChainEnumerator]
+              # @return [ConvenientService::Service::Plugins::CanHaveServiceAwareEnumerables::Entities::ServiceAwareEnumerables::Enumerator, ConvenientService::Service::Plugins::CanHaveServiceAwareEnumerables::Entities::ServiceAwareEnumerables::ChainEnumerator]
               #
               def each_with_index(&iteration_block)
                 if iteration_block
-                  with_processing_return_value_as_chain_enumerator(arguments(&iteration_block)) do |&step_aware_iteration_block|
-                    chain_enumerator.each_with_index(&step_aware_iteration_block)
+                  with_processing_return_value_as_chain_enumerator(arguments(&iteration_block)) do |&service_aware_iteration_block|
+                    chain_enumerator.each_with_index(&service_aware_iteration_block)
                   end
                 else
                   with_processing_return_value_as_enumerator do
@@ -115,12 +115,12 @@ module ConvenientService
               # @api public
               #
               # @param iteration_block [Proc, nil]
-              # @return [ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Enumerator, ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::ChainEnumerator]
+              # @return [ConvenientService::Service::Plugins::CanHaveServiceAwareEnumerables::Entities::ServiceAwareEnumerables::Enumerator, ConvenientService::Service::Plugins::CanHaveServiceAwareEnumerables::Entities::ServiceAwareEnumerables::ChainEnumerator]
               #
               def reverse_each(&iteration_block)
                 if iteration_block
-                  with_processing_return_value_as_chain_enumerator(arguments(&iteration_block)) do |&step_aware_iteration_block|
-                    chain_enumerator.reverse_each(&step_aware_iteration_block)
+                  with_processing_return_value_as_chain_enumerator(arguments(&iteration_block)) do |&service_aware_iteration_block|
+                    chain_enumerator.reverse_each(&service_aware_iteration_block)
                   end
                 else
                   with_processing_return_value_as_enumerator do