convenient_service 0.12.0 → 0.14.0

data/lib/convenient_service/service/plugins.rb

@@ -1,18 +1,26 @@
 # frozen_string_literal: true
 
 ##
-# NOTE: Order matters.
+# @internal
+#   NOTE: Order matters.
 #
+require_relative "plugins/has_result"
+require_relative "plugins/has_j_send_result"
+
 require_relative "plugins/can_recalculate_result"
 require_relative "plugins/can_have_method_steps"
-require_relative "plugins/can_have_result_step"
 require_relative "plugins/can_have_steps"
-require_relative "plugins/can_have_stubbed_result"
+require_relative "plugins/can_have_stubbed_results"
+require_relative "plugins/can_have_fallbacks"
+require_relative "plugins/collects_services_in_exception"
+require_relative "plugins/counts_stubbed_results_invocations"
 require_relative "plugins/has_inspect"
-require_relative "plugins/has_result"
-require_relative "plugins/has_result_short_syntax"
+require_relative "plugins/has_j_send_result_short_syntax"
+require_relative "plugins/has_j_send_result_status_check_short_syntax"
+require_relative "plugins/has_mermaid_flowchart"
+require_relative "plugins/raises_on_not_result_return_value"
 require_relative "plugins/raises_on_double_result"
+require_relative "plugins/sets_parent_to_foreign_result"
 require_relative "plugins/wraps_result_in_db_transaction"
-require_relative "plugins/has_result_status_check_short_syntax"
 
 require_relative "plugins/aliases"

data/lib/convenient_service/support/abstract_method/{errors.rb → exceptions.rb}

@@ -3,8 +3,8 @@
 module ConvenientService
   module Support
     module AbstractMethod
-      module Errors
-        class AbstractMethodNotOverridden < ::ConvenientService::Error
+      module Exceptions
+        class AbstractMethodNotOverridden < ::ConvenientService::Exception
           def initialize(instance:, method:)
             klass = instance.is_a?(::Class) ? instance : instance.class
             method_type = Utils::Object.resolve_type(instance)

data/lib/convenient_service/support/abstract_method.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "abstract_method/errors"
+require_relative "abstract_method/exceptions"
 
 module ConvenientService
   module Support
@@ -11,7 +11,7 @@ module ConvenientService
         def abstract_method(*names)
           names.each do |name|
             define_method(name) do |*args, **kwargs, &block|
-              raise Errors::AbstractMethodNotOverridden.new(instance: self, method: name)
+              raise Exceptions::AbstractMethodNotOverridden.new(instance: self, method: name)
             end
           end
         end

data/lib/convenient_service/support/cache/constants.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Support
+    class Cache
+      class Constants
+        module Backends
+          ##
+          # @return [Symbol]
+          #
+          ARRAY = :array
+
+          ##
+          # @return [Symbol]
+          #
+          HASH = :hash
+
+          ##
+          # @return [Symbol]
+          #
+          THREAD_SAFE_ARRAY = :thread_safe_array
+
+          ##
+          # @return [Array<Symbol>]
+          #
+          ALL = [ARRAY, HASH, THREAD_SAFE_ARRAY]
+
+          ##
+          # @return [Symbol]
+          #
+          DEFAULT = HASH
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/support/cache/entities/caches/array/entities/pair.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Support
+    class Cache
+      module Entities
+        module Caches
+          class Array < Caches::Base
+            module Entities
+              class Pair
+                ##
+                # @!attribute [r] key
+                #   @return [ConvenientService::Support::Cache::Entities::Key]
+                #
+                attr_reader :key
+
+                ##
+                # @!attribute [rw] value
+                #   @return [Object] Can be any type.
+                #
+                attr_reader :value
+
+                ##
+                # @param key [Object] Can be any type.
+                # @param value [Object] Can be any type.
+                # @return [void]
+                #
+                def initialize(key:, value:)
+                  @key = key
+                  @value = value
+                end
+
+                ##
+                # @param other [Object] Can be any type.
+                # @return [void]
+                #
+                def ==(other)
+                  return unless other.instance_of?(self.class)
+
+                  return false if key != other.key
+                  return false if value != other.value
+
+                  true
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/support/cache/entities/caches/array/entities.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "entities/pair"

data/lib/convenient_service/support/cache/entities/caches/array.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require_relative "array/entities"
+
+module ConvenientService
+  module Support
+    class Cache
+      module Entities
+        module Caches
+          class Array < Caches::Base
+            ##
+            # @return [void]
+            #
+            def initialize(array = [])
+              @array = array
+            end
+
+            ##
+            # @return [Array<ConvenientService::Support::Cache::Entities::Caches::Array::Entities::Pair>]
+            #
+            def store
+              array
+            end
+
+            ##
+            # @return [Boolean]
+            #
+            def empty?
+              array.empty?
+            end
+
+            ##
+            # @param key [Object] Can be any type.
+            # @return [Boolean]
+            #
+            def exist?(key)
+              index = index(key)
+
+              index ? true : false
+            end
+
+            ##
+            # @param key [Object] Can be any type.
+            # @return [Object] Can be any type.
+            #
+            def read(key)
+              index = index(key)
+
+              array[index].value if index
+            end
+
+            ##
+            # @param key [Object] Can be any type.
+            # @param value [Object] Can be any type.
+            # @return [Object] Can be any type.
+            #
+            def write(key, value)
+              index = index(key) || array.size
+
+              array[index] = pair(key, value)
+
+              value
+            end
+
+            ##
+            # @param key [Object] Can be any type.
+            # @param block [Proc, nil]
+            # @return [Object] Can be any type.
+            #
+            # @internal
+            #   https://api.rubyonrails.org/classes/ActiveSupport/Cache/Store.html#method-i-fetch
+            #
+            def fetch(key, &block)
+              index = index(key)
+
+              return array[index].value if index
+
+              return unless block
+
+              value = yield
+
+              array << pair(key, value)
+
+              value
+            end
+
+            ##
+            # @param key [Object] Can be any type.
+            # @return [Object] Can be any type.
+            #
+            def delete(key)
+              index = index(key)
+
+              array.delete_at(index).value if index
+            end
+
+            ##
+            # @return [ConvenientService::Support::Cache::Entities::Caches::Array]
+            #
+            def clear
+              array.clear
+
+              self
+            end
+
+            private
+
+            ##
+            # @!attribute [r] array
+            #   @return [Array]
+            #
+            attr_reader :array
+
+            ##
+            # @param key [Object] Can be any type.
+            # @return [Integer, nil]
+            #
+            def index(key)
+              array.find_index { |pair| pair.key == key }
+            end
+
+            ##
+            # @param key [Object] Can be any type.
+            # @param value [Object] Can be any type.
+            # @return [ConvenientService::Support::Cache::Entities::Caches::Array::Pair]
+            #
+            def pair(key, value)
+              Entities::Pair.new(key: key, value: value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/support/cache/entities/caches/base.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Support
+    class Cache
+      module Entities
+        module Caches
+          class Base
+            include Support::AbstractMethod
+
+            class << self
+              ##
+              # @return [ConvenientService::Support::Cache::Entities::Key]
+              #
+              def keygen(...)
+                Entities::Key.new(...)
+              end
+            end
+
+            ##
+            # @return [Boolean]
+            #
+            abstract_method :empty?
+
+            ##
+            # @return [Boolean]
+            #
+            abstract_method :exist?
+
+            ##
+            # @return [Object] Can be any type.
+            #
+            abstract_method :read
+
+            ##
+            # @return [Object] Can be any type.
+            #
+            abstract_method :write
+
+            ##
+            # @return [Object] Can be any type.
+            #
+            abstract_method :fetch
+
+            ##
+            # @return [Object, nil] Can be any type.
+            #
+            abstract_method :delete
+
+            ##
+            # @return [ConvenientService::Support::Cache::Enitities::Caches::Base]
+            #
+            abstract_method :clear
+
+            ##
+            # @return [void]
+            #
+            def initialize
+            end
+
+            ##
+            # @return [ConvenientService::Support::Cache::Entities::Key]
+            #
+            def keygen(...)
+              self.class.keygen(...)
+            end
+
+            ##
+            # @return [Object] Can be any type.
+            #
+            # @internal
+            #   NOTE: `alias_method` is NOT used in order to have an ability to use `allow(cache).to receive(:read).with(key).and_call_original` for both `cache[key]` and `cache.read(key)` in RSpec.
+            #
+            def [](...)
+              read(...)
+            end
+
+            ##
+            # @return [Object] Can be any type.
+            #
+            # @internal
+            #   NOTE: `alias_method` is NOT used in order to have an ability to use `allow(cache).to receive(:write).with(key, value).and_call_original` for both `cache[key] = value` and `cache.write(key, value)` in RSpec.
+            #
+            def []=(...)
+              write(...)
+            end
+
+            ##
+            # @param key [Object] Can be any type.
+            # @return [ConvenientService::Support::Cache::Entities::Caches::Base]
+            #
+            def scope(key)
+              fetch(key) { self.class.new }
+            end
+
+            ##
+            # @param other [Object] Can be any type.
+            # @return [Boolean, nil]
+            #
+            def ==(other)
+              return unless other.instance_of?(self.class)
+
+              return false if store != other.store
+
+              true
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/support/cache/entities/caches/hash.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Support
+    class Cache
+      module Entities
+        module Caches
+          class Hash < Caches::Base
+            ##
+            # @return [void]
+            #
+            def initialize(hash = {})
+              @hash = hash
+            end
+
+            ##
+            # @return [Hash{Object => Object}]
+            #
+            def store
+              hash
+            end
+
+            ##
+            # @return [Boolean]
+            #
+            # @internal
+            #   https://ruby-doc.org/core-2.7.0/Hash.html#method-i-empty-3F
+            #
+            def empty?
+              hash.empty?
+            end
+
+            ##
+            # @param key [Object] Can be any type.
+            # @return [Boolean]
+            #
+            # @internal
+            #   https://api.rubyonrails.org/classes/ActiveSupport/Cache/Store.html#method-i-exist-3F
+            #
+            def exist?(key)
+              hash.has_key?(key)
+            end
+
+            ##
+            # @param key [Object] Can be any type.
+            # @return [Object] Can be any type.
+            #
+            # @internal
+            #   https://api.rubyonrails.org/classes/ActiveSupport/Cache/Store.html#method-i-read
+            #
+            def read(key)
+              hash[key]
+            end
+
+            ##
+            # @param key [Object] Can be any type.
+            # @param value [Object] Can be any type.
+            # @return [Object] Can be any type.
+            #
+            # @internal
+            #   https://api.rubyonrails.org/classes/ActiveSupport/Cache/Store.html#method-i-write
+            #
+            def write(key, value)
+              hash[key] = value
+            end
+
+            ##
+            # @param key [Object] Can be any type.
+            # @param block [Proc, nil]
+            # @return [Object] Can be any type.
+            #
+            # @internal
+            #   https://api.rubyonrails.org/classes/ActiveSupport/Cache/Store.html#method-i-fetch
+            #
+            def fetch(key, &block)
+              return hash[key] unless block
+
+              hash.fetch(key) { hash[key] = yield }
+            end
+
+            ##
+            # @param key [Object] Can be any type.
+            # @return [Object] Can be any type.
+            #
+            # @internal
+            #   https://api.rubyonrails.org/classes/ActiveSupport/Cache/Store.html#method-i-delete
+            #
+            def delete(key)
+              hash.delete(key)
+            end
+
+            ##
+            # @return [ConvenientService::Support::Cache::Entities::Caches::Hash]
+            #
+            def clear
+              hash.clear
+
+              self
+            end
+
+            private
+
+            ##
+            # @!attribute [r] hash
+            #   @return [Hash]
+            #
+            attr_reader :hash
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/support/cache/entities/caches/thread_safe_array.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require_relative "array/entities"
+
+module ConvenientService
+  module Support
+    class Cache
+      module Entities
+        module Caches
+          class ThreadSafeArray < Caches::Array
+            ##
+            # @return [void]
+            #
+            def initialize(array = [])
+              super
+
+              @lock = ::Mutex.new
+            end
+
+            ##
+            # @return [Boolean]
+            #
+            def empty?(...)
+              @lock.synchronize { super }
+            end
+
+            ##
+            # @return [Boolean]
+            #
+            def exist?(...)
+              @lock.synchronize { super }
+            end
+
+            ##
+            # @return [Object] Can be any type.
+            #
+            def read(...)
+              @lock.synchronize { super }
+            end
+
+            ##
+            # @return [Object] Can be any type.
+            #
+            def write(...)
+              @lock.synchronize { super }
+            end
+
+            ##
+            # @return [Object] Can be any type.
+            #
+            def fetch(...)
+              @lock.synchronize { super }
+            end
+
+            ##
+            # @return [Object] Can be any type.
+            #
+            def delete(...)
+              @lock.synchronize { super }
+            end
+
+            ##
+            # @return [ConvenientService::Support::Cache::Entities::Caches::Array]
+            #
+            def clear(...)
+              @lock.synchronize { super }
+            end
+
+            ##
+            # @internal
+            #   `scope` method from parent delegates to thread-safe `fetch`, that is why child `scope` method does NOT require additional synchronization.
+            #
+            # def scope(...)
+            #   # ...
+            # end
+            ##
+
+            ##
+            # @note NOT thread-safe.
+            #
+            # def ==(other)
+            #   # ...
+            # end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/support/cache/entities/caches.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative "caches/base"
+
+require_relative "caches/array"
+require_relative "caches/hash"
+
+require_relative "caches/thread_safe_array"