hecks 3.4.1 → 3.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b47e9f61f073e7c8512365b3bb5112f4e214c26cec46e08a323c6f02c509d555
-  data.tar.gz: d84b642199556cc1b9bbcbc6635c2e248f3f4b63232bb0ca6abee589f85661ca
+  metadata.gz: 84b8798a316a3928051f7d6b5aa8baf4ab875e228778303cafeb6e591ada6369
+  data.tar.gz: 72bbefbce9a00405f7d1c8e7a3d0f99dcdf1fdf5f6cb8334e96b3f03cb944b4a
 SHA512:
-  metadata.gz: e2280fdb747d6d8a299bd58f4ab261e71a0d977ed805e9fcfe86ae108cc248724c96960614b9af6796d4617ef9102be1343107a91c6044123a97f298ba6002f1
-  data.tar.gz: 6558a4e9698ca6e01a665ab3d9aa435da6990e20a69ef06b0c0cd91bc0edcedc771a976dc664c4501d56883ebca1435adb534d3516a20d8fd55dca3c90ff40ff
+  metadata.gz: 82d1b5ea4652ccb5c4ce3788ea20a010e9466022853f5b187a6bb24db2a39d584337e7b6443ea3aa1cb9ed746b79863b41c40ec1ab0ba4312ad6e0dc64fb6cd5
+  data.tar.gz: d2d3d2e6b553e1d3d4ffcf98e9007af02d8f80a6bd0ffd022be797adf1571c7328a8e6e79a2b05aa407ec5086fb84e82bd00ce842c4e2dae3b2145510143a8ec

data/lib/hecks/adapters/driven/memory/shared_elements.rb

@@ -9,9 +9,12 @@ module Hecks
       # Lets a Memory save of a growing `list_of` copy and hydrate only the elements it has not
       # seen. A hydrated composite element is frozen, so its codec copy (the journal form) and
       # its hydrated form are each computed once, frozen, and shared by every journal entry and
-      # record that holds it. Shared nodes are immutable, so a caller cannot reach the journal
-      # through a returned instance. Everything else in the state goes through `StateCodec`
-      # whole. Both tables are weak and identity-keyed: a cache, never the only holder.
+      # record that holds it. A single value-object attribute that holds a list, directly or
+      # through a nested value object, shares the same way: the hydrated `Runtime::Value` is
+      # copied once, and a later version of it reuses the copies of the list elements it still
+      # holds. Shared nodes are immutable, so a caller cannot reach the journal through a
+      # returned instance. Everything else in the state goes through `StateCodec` whole. The
+      # tables are weak and identity-keyed: a cache, never the only holder.
       class SharedElements
         # @param aggregate [Bluebook::Aggregate] the aggregate whose state this shares elements of
         def initialize(aggregate)
@@ -25,6 +28,7 @@ module Hecks
         def reset!
           @journal = ObjectSpace::WeakMap.new   # live element => frozen decoded copy
           @live    = ObjectSpace::WeakMap.new   # frozen decoded copy => hydrated element
+          @copies  = ObjectSpace::WeakMap.new   # frozen value-object copy this table built => true
           self
         end
 
@@ -36,11 +40,13 @@ module Hecks
         #   are frozen and shared with every other copy that holds them, nothing else is shared
         #   with `state`
         def journal_state(state)
-          lists = shareable_lists(state)
-          return Ports::Persistence::StateCodec.copy(@aggregate, state) if lists.empty?
+          lists  = shareable_lists(state)
+          values = journal_values(state)
+          return Ports::Persistence::StateCodec.copy(@aggregate, state) if lists.empty? && values.empty?
 
-          copied = Ports::Persistence::StateCodec.copy(@aggregate, placeholders(state, lists))
+          copied = Ports::Persistence::StateCodec.copy(@aggregate, placeholders(state, lists, values))
           lists.each { |name, (attribute, elements)| copied[name] = journal_list(attribute, elements) }
+          values.each { |name, (attribute, value)| copied[name] = journal_value(attribute, value) }
           copied
         end
 
@@ -48,12 +54,14 @@ module Hecks
         #
         # @param decoded [Hash] a fresh state in the shape `journal_state` returns; its non-shared
         #   values are hydrated in place of copies, so it must not be a journal entry's own state
-        # @return [Hash{Symbol => Object}] hydrated state, defaults filled; the lists it shares
-        #   are frozen arrays of frozen elements, and nothing mutable is shared with `decoded`
+        # @return [Hash{Symbol => Object}] hydrated state, defaults filled; the lists and value
+        #   objects it shares are frozen, and nothing mutable is shared with `decoded`
         def live_state(decoded)
-          lists = shareable_lists(decoded)
-          hydrated = Runtime::Instance.hydrate_with_defaults(@aggregate, placeholders(decoded, lists))
+          lists  = shareable_lists(decoded)
+          values = live_values(decoded)
+          hydrated = Runtime::Instance.hydrate_with_defaults(@aggregate, placeholders(decoded, lists, values))
           lists.each { |name, (attribute, elements)| hydrated[name] = live_list(attribute, elements) }
+          values.each { |name, (attribute, copy)| hydrated[name] = live_value(attribute, copy) }
           hydrated
         end
 
@@ -70,26 +78,122 @@ module Hecks
           end
         end
 
-        def composite_lists
-          @composite_lists ||= @aggregate.attributes.each_with_object({}) do |attribute, found|
+        def composite_lists = list_attributes(@aggregate)
+
+        def list_attributes(owner)
+          owner.attributes.each_with_object({}) do |attribute, found|
             next unless attribute.list? && !attribute.reference? && composite?(attribute)
 
             found[attribute.name.to_sym] = attribute
           end
         end
 
+        # The attributes of the aggregate that hold one value object able to hold a list, by
+        # name. A value object with no list in it is small and is left to the codec.
+        def growable_values
+          @growable_values ||= @aggregate.attributes.each_with_object({}) do |attribute, found|
+            next if attribute.list? || attribute.reference?
+
+            shape = value_object_of(attribute)
+            found[attribute.name.to_sym] = attribute if shape && growable?(shape, [])
+          end
+        end
+
+        def value_object_of(attribute)
+          return nil unless @aggregate.respond_to?(:value_object)
+
+          Runtime::Value.value_object_for(@aggregate, attribute.type.to_s)
+        end
+
+        def growable?(shape, seen)
+          return false if seen.include?(shape)
+
+          shape.attributes.any? do |attribute|
+            next false if attribute.reference?
+            next true if attribute.list?
+
+            nested = value_object_of(attribute)
+            nested ? growable?(nested, seen + [shape]) : false
+          end
+        end
+
+        # The growable value-object attributes of `state` holding a frozen value of their type.
+        def journal_values(state)
+          return {} unless state.is_a?(Hash)
+
+          growable_values.each_with_object({}) do |(name, attribute), found|
+            value = state[name]
+            found[name] = [attribute, value] if value.is_a?(Runtime::Value) && sharable_value?(attribute, value)
+          end
+        end
+
+        def sharable_value?(attribute, value)
+          value.frozen? && value.type_name == value_object_of(attribute).hecks_name
+        end
+
+        # The growable value-object attributes of `decoded` holding a frozen Hash: a copy this
+        # table made, or one a caller froze.
+        def live_values(decoded)
+          return {} unless decoded.is_a?(Hash)
+
+          growable_values.each_with_object({}) do |(name, attribute), found|
+            copy = decoded[name]
+            found[name] = [attribute, copy] if copy.is_a?(Hash) && copy.frozen?
+          end
+        end
+
         def composite?(attribute)
           type = attribute.type.to_s
           !Runtime::Value.find_entity(@aggregate, type).nil? ||
             (@aggregate.respond_to?(:value_object) && !Runtime::Value.value_object_for(@aggregate, type).nil?)
         end
 
-        # `state` with each shared list replaced by nil, which the codec leaves alone and
-        # which holds the list's place in the key order.
-        def placeholders(state, lists)
-          return state if lists.empty?
+        # `state` with each shared list and value object replaced by nil, which the codec
+        # leaves alone and which holds its place in the key order.
+        def placeholders(state, lists, values)
+          return state if lists.empty? && values.empty?
+
+          state.merge(lists.merge(values).transform_values { nil })
+        end
+
+        # The frozen codec copy of one value object. A list it holds is rebuilt from the copies
+        # of its elements, so a new version of the value costs the new elements, not all of them.
+        def journal_value(attribute, value)
+          known = @journal[value]
+          return known if known
+
+          fields = value.raw_fields
+          lists  = value_lists(attribute, fields)
+          held   = fields.merge(lists.transform_values { nil })
+          copy   = Ports::Persistence::StateCodec.copy_list_element(@aggregate, attribute, held)
+          copy.each_value { |inner| Freezer.deep(inner) }
+          lists.each { |name, (list_attribute, elements)| copy[name] = journal_list(list_attribute, elements) }
+          @copies[copy.freeze] = true
+          @journal[value] = copy
+        end
+
+        def value_lists(attribute, fields)
+          list_attributes(value_object_of(attribute)).each_with_object({}) do |(name, list_attribute), found|
+            elements = fields[name]
+            found[name] = [list_attribute, elements] if elements.is_a?(Array)
+          end
+        end
+
+        # The hydrated value for one frozen copy, its lists rebuilt from the hydrated elements
+        # already held.
+        def live_value(attribute, copy)
+          known = @live[copy]
+          return known if known
+
+          lists  = value_lists(attribute, copy)
+          fields = copy.merge(lists.to_h { |name, (list_attribute, elements)| [name, live_list(list_attribute, elements)] })
+          live   = Runtime::Value.trusting_stored_state do
+            Runtime::Value.for_attribute(@aggregate, attribute, fields)
+          end
+          return live unless @copies.key?(copy)
 
-          state.merge(lists.transform_values { nil })
+          @journal[live] = copy
+          @live[copy] = live
         end
 
         def journal_list(attribute, elements)