convenient_service 0.17.0 → 0.18.0

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

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module CanHaveConnectedSteps
+        module Entities
+          module Expressions
+            class And < Entities::Expressions::Base
+              ##
+              # @!attribute [r] left_expression
+              #   @return [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::Base]
+              #
+              attr_reader :left_expression
+
+              ##
+              # @!attribute [r] right_expression
+              #   @return [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::Base]
+              #
+              attr_reader :right_expression
+
+              ##
+              # @param left_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)
+                @left_expression = left_expression
+                @right_expression = right_expression
+              end
+
+              ##
+              # @return [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result]
+              #
+              def result
+                left_expression.success? ? right_expression.result : left_expression.result
+              end
+
+              ##
+              # @return [Boolean]
+              #
+              def success?
+                left_expression.success? && right_expression.success?
+              end
+
+              ##
+              # @return [Boolean]
+              #
+              def failure?
+                return true if left_expression.failure?
+                return false if left_expression.error?
+
+                right_expression.failure?
+              end
+
+              ##
+              # @return [Boolean]
+              #
+              def error?
+                left_expression.error? || right_expression.error?
+              end
+
+              ##
+              # @param block [Proc]
+              # @return [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::Base]
+              #
+              def each_step(&block)
+                left_expression.each_step(&block)
+                right_expression.each_step(&block)
+
+                self
+              end
+
+              ##
+              # @param block [Proc]
+              # @return [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::Base]
+              #
+              def each_evaluated_step(&block)
+                left_expression.each_evaluated_step(&block)
+
+                right_expression.each_evaluated_step(&block) if left_expression.success?
+
+                self
+              end
+
+              ##
+              # @param organizer [ConvenientService::Service]
+              # @return [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::Not]
+              #
+              def with_organizer(organizer)
+                copy(overrides: {args: {0 => left_expression.with_organizer(organizer), 1 => right_expression.with_organizer(organizer)}})
+              end
+
+              ##
+              # @return [String]
+              #
+              def inspect
+                "#{left_expression.inspect} && #{right_expression.inspect}"
+              end
+
+              ##
+              # @return [Boolean]
+              #
+              def and?
+                true
+              end
+
+              ##
+              # @param other [Object] Can be any type.
+              # @return [Boolean]
+              #
+              def ==(other)
+                return unless other.instance_of?(self.class)
+
+                return false if left_expression != other.left_expression
+                return false if right_expression != other.right_expression
+
+                true
+              end
+
+              ##
+              # @return [ConvenientService::Support::Arguments]
+              #
+              def to_arguments
+                Support::Arguments.new(left_expression, right_expression)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module CanHaveConnectedSteps
+        module Entities
+          module Expressions
+            class Base
+              include Support::AbstractMethod
+              include Support::Copyable
+
+              ##
+              # @return [void]
+              #
+              abstract_method :initialize
+
+              ##
+              # @return [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result]
+              #
+              abstract_method :result
+
+              ##
+              # @return [Boolean]
+              #
+              abstract_method :success?
+
+              ##
+              # @return [Boolean]
+              #
+              abstract_method :failure?
+
+              ##
+              # @return [Boolean]
+              #
+              abstract_method :error?
+
+              ##
+              # @return [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::Base]
+              #
+              abstract_method :each_step
+
+              ##
+              # @return [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::Base]
+              #
+              abstract_method :each_evaluated_step
+
+              ##
+              # @return [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::Base]
+              #
+              abstract_method :with_organizer
+
+              ##
+              # @return [String]
+              #
+              abstract_method :inspect
+
+              ##
+              # @return [Boolean, nil]
+              #
+              abstract_method :==
+
+              ##
+              # @return [Boolean, nil]
+              #
+              abstract_method :to_arguments
+
+              ##
+              # @return [Array<ConvenientService::Service::Plugins::CanHaveSteps::Entities::Step>]
+              #
+              def steps
+                array = []
+
+                each_step { |step| array << step }
+
+                array
+              end
+
+              ##
+              # @return [Boolean]
+              #
+              def scalar?
+                false
+              end
+
+              ##
+              # @return [Boolean]
+              #
+              def not?
+                false
+              end
+
+              ##
+              # @return [Boolean]
+              #
+              def and?
+                false
+              end
+
+              ##
+              # @return [Boolean]
+              #
+              def or?
+                false
+              end
+
+              ##
+              # @return [Boolean]
+              #
+              def group?
+                false
+              end
+
+              ##
+              # @return [Boolean]
+              #
+              def empty?
+                false
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module CanHaveConnectedSteps
+        module Entities
+          module Expressions
+            class Empty < Entities::Expressions::Base
+              ##
+              # @return [void]
+              #
+              def initialize
+              end
+
+              ##
+              # @raise [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Exceptions::EmptyExpressionHasNoResult]
+              #
+              def result
+                raise Exceptions::EmptyExpressionHasNoResult.new
+              end
+
+              ##
+              # @raise [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Exceptions::EmptyExpressionHasNoStatus]
+              #
+              def success?
+                raise Exceptions::EmptyExpressionHasNoStatus.new
+              end
+
+              ##
+              # @raise [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Exceptions::EmptyExpressionHasNoStatus]
+              #
+              def failure?
+                raise Exceptions::EmptyExpressionHasNoStatus.new
+              end
+
+              ##
+              # @raise [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Exceptions::EmptyExpressionHasNoStatus]
+              #
+              def error?
+                raise Exceptions::EmptyExpressionHasNoStatus.new
+              end
+
+              ##
+              # @param block [Proc]
+              # @return [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::Base]
+              #
+              def each_step(&block)
+                self
+              end
+
+              ##
+              # @param block [Proc]
+              # @return [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::Base]
+              #
+              def each_evaluated_step(&block)
+                self
+              end
+
+              ##
+              # @param organizer [ConvenientService::Service]
+              # @return [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::Empty]
+              #
+              def with_organizer(organizer)
+                self
+              end
+
+              ##
+              # @return [String]
+              #
+              def inspect
+                ""
+              end
+
+              ##
+              # @return [Boolean]
+              #
+              def empty?
+                true
+              end
+
+              ##
+              # @param other [Object] Can be any type.
+              # @return [Boolean]
+              #
+              def ==(other)
+                return unless other.instance_of?(self.class)
+
+                true
+              end
+
+              ##
+              # @return [ConvenientService::Support::Arguments]
+              #
+              def to_arguments
+                Support::Arguments.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module CanHaveConnectedSteps
+        module Entities
+          module Expressions
+            class Group < 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 [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
+                "(#{expression.inspect})"
+              end
+
+              ##
+              # @return [Boolean]
+              #
+              def group?
+                true
+              end
+
+              ##
+              # @param other [Object] Can be any type.
+              # @return [Boolean]
+              #
+              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/not.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module CanHaveConnectedSteps
+        module Entities
+          module Expressions
+            class Not < 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.negated_result
+              end
+
+              ##
+              # @return [Boolean]
+              #
+              def success?
+                expression.failure?
+              end
+
+              ##
+              # @return [Boolean]
+              #
+              def failure?
+                expression.success?
+              end
+
+              ##
+              # @return [Boolean]
+              #
+              def error?
+                expression.error?
+              end
+
+              ##
+              # @param block [Proc]
+              # @return [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::Not]
+              #
+              def each_step(&block)
+                expression.each_step(&block)
+
+                self
+              end
+
+              ##
+              # @param block [Proc]
+              # @return [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::Not]
+              #
+              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
+                "!#{expression.inspect}"
+              end
+
+              ##
+              # @return [Boolean]
+              #
+              def not?
+                true
+              end
+
+              ##
+              # @param other [Object] Can be any type.
+              # @return [Boolean]
+              #
+              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