evt-entity_cache 0.13.0.0 → 0.14.0.0

data/lib/entity_cache/record.rb

@@ -1,44 +1,50 @@
 class EntityCache
-  class Record < Struct.new(:id, :entity, :version, :time, :persisted_version, :persisted_time)
-    def versions_since_persisted
-      persisted_version = self.persisted_version
-      persisted_version ||= -1
-
-      version - persisted_version.to_i
+  Record = Struct.new(
+    :id,
+    :entity,
+    :version,
+    :time,
+    :persisted_version,
+    :persisted_time
+  )
+
+  class Record
+    dependency :clock, Clock::UTC
+
+    def configure
+      Clock::UTC.configure(self)
     end
 
-    def destructure(includes=nil)
-      return entity if includes.nil?
-
-      responses = [entity]
-
-      includes = Array(includes)
-
-      includes.each do |attribute|
-        value = public_send attribute
-
-        if value.nil? && attribute == :version
-          value = NoStream.version
-        end
-
-        responses << value
-      end
+    def self.build(id, entity, version, time, persisted_version: nil, persisted_time: nil)
+      instance = new(id, entity, version, time, persisted_version, persisted_time)
+      instance.configure
+      instance
+    end
 
-      responses
+    def self.destructure(instance, includes=nil)
+      Destructure.(instance, includes)
     end
 
     def age_milliseconds
-      Clock::UTC.elapsed_milliseconds(time, Clock::UTC.now)
+      Clock::UTC.elapsed_milliseconds(time, clock.now)
     end
 
-    module NoStream
-      def self.destructure(includes=nil)
-        record = Record.new
-        record.destructure(includes)
+    def persisted_age_milliseconds
+      if persisted_time.nil?
+        nil
+      else
+        Clock::UTC.elapsed_milliseconds(
+          persisted_time,
+          time
+        )
       end
+    end
 
-      def self.version
-        :no_stream
+    def persisted_age_versions
+      if persisted_version.nil?
+        nil
+      else
+        version - persisted_version
       end
     end
   end

data/lib/entity_cache/record/destructure.rb

@@ -0,0 +1,29 @@
+class EntityCache
+  class Record
+    module Destructure
+      def self.call(record, includes=nil)
+        record ||= NoStream.record
+
+        return record.entity if includes.nil?
+
+        return_values = Array(includes).map do |attribute|
+          record.public_send(attribute)
+        end
+
+        return record.entity, *return_values
+      end
+
+      module NoStream
+        def self.record
+          @record ||= build_record
+        end
+
+        def self.build_record
+          record = Record.new
+          record.version = MessageStore::NoStream.name
+          record
+        end
+      end
+    end
+  end
+end

data/lib/entity_cache/record/log_text.rb

@@ -0,0 +1,9 @@
+class EntityCache
+  class Record
+    module LogText
+      def self.get(record)
+        "Entity: #{record&.entity.class}, Version: #{record&.version.inspect}, Time: #{record&.time.inspect}, Persisted Version: #{record&.persisted_version.inspect}, Persisted Time: #{record&.persisted_time.inspect}"
+      end
+    end
+  end
+end

data/lib/entity_cache/record/transformer.rb

@@ -0,0 +1,26 @@
+class EntityCache
+  class Record
+    module Transformer
+      def self.raw_data(instance)
+        raw_data = instance.to_h
+
+        entity = raw_data.delete(:entity)
+        copied_entity = Transform::Copy.(entity)
+
+        raw_data[:entity] = copied_entity
+
+        raw_data
+      end
+
+      def self.instance(raw_data)
+        instance = Record.new
+
+        raw_data.each do |attribute, value|
+          instance.public_send("#{attribute}=", value)
+        end
+
+        instance
+      end
+    end
+  end
+end

data/lib/entity_cache/store/persistent/null.rb

@@ -0,0 +1,15 @@
+class EntityCache
+  module Store
+    module Persistent
+      class Null
+        include Store::Persistent
+
+        def get(id)
+        end
+
+        def put(id, entity, version, time)
+        end
+      end
+    end
+  end
+end

data/lib/entity_cache/store/persistent/substitute.rb

@@ -0,0 +1,64 @@
+class EntityCache
+  module Store
+    module Persistent
+      module Substitute
+        def self.build
+          Persistent.build
+        end
+
+        class Persistent
+          include Store::Persistent
+
+          attr_accessor :telemetry_sink
+
+          def self.build
+            instance = new(subject)
+            instance.configure
+            instance
+          end
+
+          def configure(session: nil)
+            self.telemetry_sink = self.class.register_telemetry_sink(self)
+          end
+
+          def get(id)
+            record = get_records[id]
+
+            if record
+              return record.entity, record.version, record.time
+            end
+          end
+
+          def get_records
+            @get_records ||= {}
+          end
+
+          def add(id, entity, version, time)
+            record = Record.new(id, entity, version, time)
+
+            get_records[id] = record
+
+            record
+          end
+
+          def put(*)
+          end
+
+          def put?(&block)
+            block ||= proc { true }
+
+            telemetry_sink.recorded_put? do |record|
+              data = record.data
+
+              block.(data.id, data.entity, data.version, data.time)
+            end
+          end
+
+          def self.subject
+            :substitute
+          end
+        end
+      end
+    end
+  end
+end

data/lib/entity_cache/store/persistent/telemetry.rb

@@ -0,0 +1,16 @@
+class EntityCache
+  module Store
+    module Persistent
+      module Telemetry
+        Data = Struct.new(:id, :entity, :version, :time)
+
+        class Sink
+          include ::Telemetry::Sink
+
+          record :put
+          record :get
+        end
+      end
+    end
+  end
+end

data/lib/entity_cache/store/temporary.rb

@@ -0,0 +1,47 @@
+class EntityCache
+  module Store
+    class Temporary
+      include Log::Dependency
+
+      attr_accessor :subject
+
+      def self.build(subject)
+        instance = new
+        instance.subject = subject
+        instance
+      end
+
+      def self.configure(receiver, subject, scope: nil, attr_name: nil)
+        attr_name ||= :temporary_store
+
+        instance = Build.(subject, scope: scope)
+        receiver.public_send("#{attr_name}=", instance)
+        instance
+      end
+
+      abstract :records
+
+      def get(id)
+        logger.trace { "Getting Entity (ID: #{id.inspect})" }
+
+        record = records[id]
+
+        logger.debug { "Get entity done (ID: #{id.inspect}, #{Record::LogText.get(record)})" }
+
+        record
+      end
+
+      def put(record)
+        id = record.id
+
+        logger.trace { "Putting entity (ID: #{id.inspect}, #{Record::LogText.get(record)})" }
+
+        records[id] = record
+
+        logger.trace { "Put entity done (ID: #{id.inspect}, #{Record::LogText.get(record)})" }
+
+        record
+      end
+    end
+  end
+end

data/lib/entity_cache/store/temporary/build.rb

@@ -0,0 +1,48 @@
+class EntityCache
+  module Store
+    class Temporary
+      module Build
+        def self.call(subject, scope: nil)
+          scope ||= Defaults.scope
+
+          cls = scope_class(scope)
+
+          cls.build(subject)
+        end
+
+        def self.default_scope_class
+          scope_class(Defaults.scope)
+        end
+
+        def self.scope_class(scope)
+          scopes.fetch(scope) do
+            *scopes, final_scope = self.scopes.keys
+
+            scope_list = <<~TEXT
+            #{scopes.map(&:inspect) * ', '} or #{final_scope.inspect}
+            TEXT
+
+            error_message = %{Scope #{scope.inspect} is unknown. It must be one of: #{scope_list}}
+
+            logger.error(error_message)
+            raise ScopeError, error_message
+          end
+        end
+
+        def self.scopes
+          @scopes ||= {
+            :exclusive => Scope::Exclusive,
+            :global => Scope::Global,
+            :thread => Scope::Thread
+          }
+        end
+
+        def self.logger
+          @logger ||= Log.get(self)
+        end
+
+        ScopeError = Class.new(StandardError)
+      end
+    end
+  end
+end

data/lib/entity_cache/store/temporary/build/defaults.rb

@@ -0,0 +1,28 @@
+class EntityCache
+  module Store
+    class Temporary
+      module Build
+        module Defaults
+          def self.scope
+            Scope.get
+          end
+
+          module Scope
+            def self.get
+              value = ENV.fetch(env_var, default)
+              value.to_sym
+            end
+
+            def self.env_var
+              'ENTITY_CACHE_SCOPE'
+            end
+
+            def self.default
+              'thread'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/entity_cache/{storage → store}/temporary/scope/exclusive.rb

@@ -1,5 +1,5 @@
 class EntityCache
-  module Storage
+  module Store
     class Temporary
       module Scope
         class Exclusive < Temporary

data/lib/entity_cache/store/temporary/scope/global.rb

@@ -0,0 +1,34 @@
+class EntityCache
+  module Store
+    class Temporary
+      module Scope
+        class Global < Temporary
+          def records
+            records_by_subject[subject]
+          end
+
+          def records_by_subject
+            mutex.synchronize do
+              @@records_by_subject ||= {}
+              @@records_by_subject[subject] ||= ThreadSafeHash.new
+              @@records_by_subject
+            end
+          end
+
+          mutex = ::Thread::Mutex.new
+          define_method(:mutex) do
+            mutex
+          end
+
+          class ThreadSafeHash < ::Hash
+            def [](key)
+              value = super(key)
+              value = Transform::Copy.(value) unless value.nil?
+              value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/entity_cache/store/temporary/scope/thread.rb

@@ -0,0 +1,35 @@
+class EntityCache
+  module Store
+    class Temporary
+      module Scope
+        class Thread < Temporary
+          def records
+            records_by_subject[subject]
+          end
+
+          def records_by_subject
+            current_thread = ::Thread.current
+
+            records_by_subject = current_thread.thread_variable_get(thread_variable)
+
+            if records_by_subject.nil?
+              records_by_subject = Hash.new do |hash, subject|
+                hash[subject] = {}
+              end
+
+              current_thread.thread_variable_set(thread_variable, records_by_subject)
+            end
+
+            records_by_subject
+          end
+
+          thread_variable = :"entity_cache_records_by_subject_#{SecureRandom.hex(7)}"
+
+          define_method(:thread_variable) do
+            thread_variable
+          end
+        end
+      end
+    end
+  end
+end