convenient_service 0.19.1 → 0.20.0

data/lib/convenient_service/service/plugins/can_have_connected_steps/entities/expressions/base.rb

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
+##
+# @author Marian Kostyk <mariankostyk13895@gmail.com>
+# @license LGPLv3 <https://www.gnu.org/licenses/lgpl-3.0.html>
+##
+
 module ConvenientService
   module Service
     module Plugins
@@ -20,6 +25,11 @@ module ConvenientService
               #
               abstract_method :result
 
+              ##
+              # @return [ConvenientService::Service]
+              #
+              abstract_method :organizer
+
               ##
               # @return [Boolean]
               #
@@ -117,6 +127,27 @@ module ConvenientService
               def empty?
                 false
               end
+
+              ##
+              # @return [Boolean]
+              #
+              def if?
+                false
+              end
+
+              ##
+              # @return [Boolean]
+              #
+              def else?
+                false
+              end
+
+              ##
+              # @return [Boolean]
+              #
+              def complex_if?
+                false
+              end
             end
           end
         end

data/lib/convenient_service/service/plugins/can_have_connected_steps/entities/expressions/complex_if.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+##
+# @author Marian Kostyk <mariankostyk13895@gmail.com>
+# @license LGPLv3 <https://www.gnu.org/licenses/lgpl-3.0.html>
+##
+
+module ConvenientService
+  module Service
+    module Plugins
+      module CanHaveConnectedSteps
+        module Entities
+          module Expressions
+            class ComplexIf < Entities::Expressions::Base
+              ##
+              # @!attribute [r] if_expression
+              #   @return [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::If]
+              #
+              attr_reader :if_expression
+
+              ##
+              # @!attribute [r] elsif_expressions
+              #   @return [Array<ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::If>]
+              #
+              attr_reader :elsif_expressions
+
+              ##
+              # @!attribute [r] else_expression
+              #   @return [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::Else]
+              #
+              attr_reader :else_expression
+
+              ##
+              # @param if_expression [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::If]
+              # @param elsif_expressions [Array<ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::If>]
+              # @param else_expression [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::Else, nil]
+              # @return [void]
+              #
+              def initialize(if_expression, elsif_expressions, else_expression)
+                @if_expression = if_expression
+                @elsif_expressions = elsif_expressions
+                @else_expression = else_expression
+              end
+
+              ##
+              # @return [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result]
+              #
+              def result
+                return if_expression.condition_expression.result if if_expression.condition_expression.error?
+                return if_expression.then_expression.result if if_expression.condition_expression.success?
+
+                elsif_expressions.each do |elsif_expression|
+                  return elsif_expression.condition_expression.result if elsif_expression.condition_expression.error?
+                  return elsif_expression.then_expression.result if elsif_expression.condition_expression.success?
+                end
+
+                else_expression ? else_expression.result : organizer.success
+              end
+
+              ##
+              # @return [ConvenientService::Service]
+              #
+              def organizer
+                if_expression.organizer
+              end
+
+              ##
+              # @return [Boolean]
+              #
+              def success?
+                return false if if_expression.condition_expression.error?
+                return if_expression.then_expression.success? if if_expression.condition_expression.success?
+
+                elsif_expressions.each do |elsif_expression|
+                  return false if elsif_expression.condition_expression.error?
+                  return elsif_expression.then_expression.success? if elsif_expression.condition_expression.success?
+                end
+
+                else_expression ? else_expression.success? : true
+              end
+
+              ##
+              # @return [Boolean]
+              #
+              def failure?
+                return false if if_expression.condition_expression.error?
+                return if_expression.then_expression.failure? if if_expression.condition_expression.success?
+
+                elsif_expressions.each do |elsif_expression|
+                  return false if elsif_expression.condition_expression.error?
+                  return elsif_expression.then_expression.failure? if elsif_expression.condition_expression.success?
+                end
+
+                else_expression ? else_expression.failure? : false
+              end
+
+              ##
+              # @return [Boolean]
+              #
+              def error?
+                return true if if_expression.condition_expression.error?
+                return if_expression.then_expression.error? if if_expression.condition_expression.success?
+
+                elsif_expressions.each do |elsif_expression|
+                  return true if elsif_expression.condition_expression.error?
+                  return elsif_expression.then_expression.error? if elsif_expression.condition_expression.success?
+                end
+
+                else_expression ? else_expression.error? : false
+              end
+
+              ##
+              # @param block [Proc]
+              # @return [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::Base]
+              #
+              def each_step(&block)
+                if_expression.each_step(&block)
+
+                elsif_expressions.each do |elsif_expression|
+                  elsif_expression.each_step(&block)
+                end
+
+                else_expression&.each_step(&block)
+
+                self
+              end
+
+              ##
+              # @param block [Proc]
+              # @return [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::Base]
+              #
+              # rubocop:disable Lint/NonLocalExitFromIterator
+              def each_evaluated_step(&block)
+                if_expression.condition_expression.each_evaluated_step(&block)
+
+                return if if_expression.condition_expression.error?
+                return if_expression.then_expression.each_evaluated_step(&block) if if_expression.condition_expression.success?
+
+                elsif_expressions.each do |elsif_expression|
+                  elsif_expression.condition_expression.each_evaluated_step(&block)
+
+                  return if elsif_expression.condition_expression.error?
+                  return elsif_expression.then_expression.each_evaluated_step(&block) if elsif_expression.condition_expression.success?
+                end
+
+                else_expression&.each_evaluated_step(&block)
+
+                self
+              end
+              # rubocop:enable Lint/NonLocalExitFromIterator
+
+              ##
+              # @param organizer [ConvenientService::Service]
+              # @return [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::Not]
+              #
+              def with_organizer(organizer)
+                copy(
+                  overrides: {
+                    args: {
+                      0 => if_expression.with_organizer(organizer),
+                      1 => elsif_expressions.map { |elsif_expression| elsif_expression.with_organizer(organizer) },
+                      2 => else_expression&.with_organizer(organizer)
+                    }
+                  }
+                )
+              end
+
+              ##
+              # @return [String]
+              #
+              def inspect
+                parts = [
+                  "if #{if_expression.condition_expression.inspect} then #{if_expression.then_expression.inspect}"
+                ]
+
+                elsif_expressions.each do |elsif_expression|
+                  parts << "elsif #{elsif_expression.condition_expression.inspect} then #{elsif_expression.then_expression.inspect}"
+                end
+
+                parts << "else #{else_expression.expression.inspect}" if else_expression
+
+                parts << "end"
+
+                parts.join(" ")
+              end
+
+              ##
+              # @return [Boolean]
+              #
+              def complex_if?
+                true
+              end
+
+              ##
+              # @param other [Object] Can be any type.
+              # @return [Boolean, nil]
+              #
+              def ==(other)
+                return unless other.instance_of?(self.class)
+
+                return false if if_expression != other.if_expression
+                return false if elsif_expressions != other.elsif_expressions
+                return false if else_expression != other.else_expression
+
+                true
+              end
+
+              ##
+              # @return [ConvenientService::Support::Arguments]
+              #
+              def to_arguments
+                Support::Arguments.new(if_expression, elsif_expressions, else_expression)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/can_have_connected_steps/entities/expressions/else.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+##
+# @author Marian Kostyk <mariankostyk13895@gmail.com>
+# @license LGPLv3 <https://www.gnu.org/licenses/lgpl-3.0.html>
+##
+
+module ConvenientService
+  module Service
+    module Plugins
+      module CanHaveConnectedSteps
+        module Entities
+          module Expressions
+            class Else < Entities::Expressions::Base
+              ##
+              # @!attribute [r] expression
+              #   @return [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::Base]
+              #
+              attr_reader :expression
+
+              ##
+              # @param expression [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::Base]
+              # @return [void]
+              #
+              def initialize(expression)
+                @expression = expression
+              end
+
+              ##
+              # @return [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result]
+              #
+              def result
+                expression.result
+              end
+
+              ##
+              # @return [ConvenientService::Service]
+              #
+              def organizer
+                expression.organizer
+              end
+
+              ##
+              # @return [Boolean]
+              #
+              def success?
+                expression.success?
+              end
+
+              ##
+              # @return [Boolean]
+              #
+              def failure?
+                expression.failure?
+              end
+
+              ##
+              # @return [Boolean]
+              #
+              def error?
+                expression.error?
+              end
+
+              ##
+              # @param block [Proc]
+              # @return [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::Base]
+              #
+              def each_step(&block)
+                expression.each_step(&block)
+
+                self
+              end
+
+              ##
+              # @param block [Proc]
+              # @return [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::Base]
+              #
+              def each_evaluated_step(&block)
+                expression.each_evaluated_step(&block)
+
+                self
+              end
+
+              ##
+              # @param organizer [ConvenientService::Service]
+              # @return [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::Not]
+              #
+              def with_organizer(organizer)
+                copy(overrides: {args: {0 => expression.with_organizer(organizer)}})
+              end
+
+              ##
+              # @return [String]
+              #
+              def inspect
+                "else #{expression.inspect} end"
+              end
+
+              ##
+              # @return [Boolean]
+              #
+              def else?
+                true
+              end
+
+              ##
+              # @param other [Object] Can be any type.
+              # @return [Boolean, nil]
+              #
+              def ==(other)
+                return unless other.instance_of?(self.class)
+
+                return false if expression != other.expression
+
+                true
+              end
+
+              ##
+              # @return [ConvenientService::Support::Arguments]
+              #
+              def to_arguments
+                Support::Arguments.new(expression)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/can_have_connected_steps/entities/expressions/empty.rb

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
+##
+# @author Marian Kostyk <mariankostyk13895@gmail.com>
+# @license LGPLv3 <https://www.gnu.org/licenses/lgpl-3.0.html>
+##
+
 module ConvenientService
   module Service
     module Plugins
@@ -20,6 +25,13 @@ module ConvenientService
                 ::ConvenientService.raise Exceptions::EmptyExpressionHasNoResult.new
               end
 
+              ##
+              # @raise [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Exceptions::EmptyExpressionHasNoOrganizer]
+              #
+              def organizer
+                ::ConvenientService.raise Exceptions::EmptyExpressionHasNoOrganizer.new
+              end
+
               ##
               # @raise [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Exceptions::EmptyExpressionHasNoStatus]
               #
@@ -81,7 +93,7 @@ module ConvenientService
 
               ##
               # @param other [Object] Can be any type.
-              # @return [Boolean]
+              # @return [Boolean, nil]
               #
               def ==(other)
                 return unless other.instance_of?(self.class)

data/lib/convenient_service/service/plugins/can_have_connected_steps/entities/expressions/group.rb

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
+##
+# @author Marian Kostyk <mariankostyk13895@gmail.com>
+# @license LGPLv3 <https://www.gnu.org/licenses/lgpl-3.0.html>
+##
+
 module ConvenientService
   module Service
     module Plugins
@@ -14,7 +19,7 @@ module ConvenientService
               attr_reader :expression
 
               ##
-              # @param expression [[ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::Base]
+              # @param expression [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::Base]
               # @return [void]
               #
               def initialize(expression)
@@ -28,6 +33,13 @@ module ConvenientService
                 expression.result
               end
 
+              ##
+              # @return [ConvenientService::Service]
+              #
+              def organizer
+                expression.organizer
+              end
+
               ##
               # @return [Boolean]
               #
@@ -93,7 +105,7 @@ module ConvenientService
 
               ##
               # @param other [Object] Can be any type.
-              # @return [Boolean]
+              # @return [Boolean, nil]
               #
               def ==(other)
                 return unless other.instance_of?(self.class)

data/lib/convenient_service/service/plugins/can_have_connected_steps/entities/expressions/if.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+##
+# @author Marian Kostyk <mariankostyk13895@gmail.com>
+# @license LGPLv3 <https://www.gnu.org/licenses/lgpl-3.0.html>
+##
+
+module ConvenientService
+  module Service
+    module Plugins
+      module CanHaveConnectedSteps
+        module Entities
+          module Expressions
+            class If < Entities::Expressions::Base
+              ##
+              # @!attribute [r] condition_expression
+              #   @return [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::Base]
+              #
+              attr_reader :condition_expression
+
+              ##
+              # @!attribute [r] then_expression
+              #   @return [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::Base]
+              #
+              attr_reader :then_expression
+
+              ##
+              # @param condition_expression [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::Base]
+              # @param then_expression [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::Base]
+              # @return [void]
+              #
+              def initialize(condition_expression, then_expression)
+                @condition_expression = condition_expression
+                @then_expression = then_expression
+              end
+
+              ##
+              # @return [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result]
+              #
+              def result
+                condition_expression.success? ? then_expression.result : condition_expression.result
+              end
+
+              ##
+              # @return [ConvenientService::Service]
+              #
+              def organizer
+                condition_expression.organizer
+              end
+
+              ##
+              # @return [Boolean]
+              #
+              def success?
+                condition_expression.success? && then_expression.success?
+              end
+
+              ##
+              # @return [Boolean]
+              #
+              def failure?
+                return true if condition_expression.failure?
+                return false if condition_expression.error?
+
+                then_expression.failure?
+              end
+
+              ##
+              # @return [Boolean]
+              #
+              def error?
+                return false if condition_expression.failure?
+                return true if condition_expression.error?
+
+                then_expression.error?
+              end
+
+              ##
+              # @param block [Proc]
+              # @return [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::Base]
+              #
+              def each_step(&block)
+                condition_expression.each_step(&block)
+
+                then_expression.each_step(&block)
+
+                self
+              end
+
+              ##
+              # @param block [Proc]
+              # @return [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::Base]
+              #
+              def each_evaluated_step(&block)
+                condition_expression.each_evaluated_step(&block)
+
+                then_expression.each_evaluated_step(&block) if condition_expression.success?
+
+                self
+              end
+
+              ##
+              # @param organizer [ConvenientService::Service]
+              # @return [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::Not]
+              #
+              def with_organizer(organizer)
+                copy(overrides: {args: {0 => condition_expression.with_organizer(organizer), 1 => then_expression.with_organizer(organizer)}})
+              end
+
+              ##
+              # @return [String]
+              #
+              def inspect
+                "if #{condition_expression.inspect} then #{then_expression.inspect} end"
+              end
+
+              ##
+              # @return [Boolean]
+              #
+              def if?
+                true
+              end
+
+              ##
+              # @param other [Object] Can be any type.
+              # @return [Boolean, nil]
+              #
+              def ==(other)
+                return unless other.instance_of?(self.class)
+
+                return false if condition_expression != other.condition_expression
+                return false if then_expression != other.then_expression
+
+                true
+              end
+
+              ##
+              # @return [ConvenientService::Support::Arguments]
+              #
+              def to_arguments
+                Support::Arguments.new(condition_expression, then_expression)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/can_have_connected_steps/entities/expressions/not.rb

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
+##
+# @author Marian Kostyk <mariankostyk13895@gmail.com>
+# @license LGPLv3 <https://www.gnu.org/licenses/lgpl-3.0.html>
+##
+
 module ConvenientService
   module Service
     module Plugins
@@ -28,6 +33,13 @@ module ConvenientService
                 expression.result.negated_result
               end
 
+              ##
+              # @return [ConvenientService::Service]
+              #
+              def organizer
+                expression.organizer
+              end
+
               ##
               # @return [Boolean]
               #
@@ -93,7 +105,7 @@ module ConvenientService
 
               ##
               # @param other [Object] Can be any type.
-              # @return [Boolean]
+              # @return [Boolean, nil]
               #
               def ==(other)
                 return unless other.instance_of?(self.class)

data/lib/convenient_service/service/plugins/can_have_connected_steps/entities/expressions/or.rb

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
+##
+# @author Marian Kostyk <mariankostyk13895@gmail.com>
+# @license LGPLv3 <https://www.gnu.org/licenses/lgpl-3.0.html>
+##
+
 module ConvenientService
   module Service
     module Plugins
@@ -21,7 +26,7 @@ module ConvenientService
 
               ##
               # @param left_expression [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::Base]
-              # @param right_expression [[ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::Base]
+              # @param right_expression [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::Base]
               # @return [void]
               #
               def initialize(left_expression, right_expression)
@@ -39,6 +44,13 @@ module ConvenientService
                 right_expression.result
               end
 
+              ##
+              # @return [ConvenientService::Service]
+              #
+              def organizer
+                left_expression.organizer
+              end
+
               ##
               # @return [Boolean]
               #
@@ -125,7 +137,7 @@ module ConvenientService
 
               ##
               # @param other [Object] Can be any type.
-              # @return [Boolean]
+              # @return [Boolean, nil]
               #
               def ==(other)
                 return unless other.instance_of?(self.class)