foobara 0.0.130 → 0.0.131

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5dd322e7389be1e600f98133b9e92a177f1d14a1b2c0d4200e7b9630fd023983
-  data.tar.gz: 6518a4d6ac731b1973809640058b8e793ebcd9dc0d014827713fc2466fe209d9
+  metadata.gz: c95217bebc01ab27c28cdf572b5e19eb2902fd68b1bb4d7328c093b02cfe8dbf
+  data.tar.gz: 76d32046c22f96ebf9e73d738aa4154fea3edb740e66fab71954abbd8594a35c
 SHA512:
-  metadata.gz: 96d8ca1ee65877ae7315052668cdff9c247ee778f5d285d4828145b3c69f06402fc97b4085744315f76b30dad36d5a9bd7f4a753108a1195950c4676c9cf16e1
-  data.tar.gz: a3ee1b0364e55f320ea2272b17f6a49d0a5e5a4d7406c3f9aa65fb8b04cdbf7b5c1169db6ae06adb3851edc62ae595614011a95b6b0ffa4767e672466f2c855c
+  metadata.gz: 148fe1548cc4731673ffa299fe1d5ef96a8377cdbc613e3aeff989b16efbc250beea9b58f1b3b1727d0b399b5f1925186c1ac97908c8e2bf6113f4ff0cba1835
+  data.tar.gz: e49bad06d6f305b4e1716fd56fa47298028c6b699977e95417e9013c95f3a25a90ca8a9b2d96b8a11c9fb5989b56587ee87d7b719d2397b90d95210168a594ce

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [0.0.131] - 2025-06-16
+
+- Extract InMemoryMinimal crud driver specs to foobara-crud-driver-spec-helpers gem
+- Better support for nested transactions
+- Fix buggy actions carried out when committing/rolling back transactions
+- Fix thread leaks in WeakObjectSet and test suite
+
 # [0.0.130] - 2025-06-06
 
 - Support using a proc as an attributes default for lazy evaluation of default values

data/projects/in_memory_crud_driver_minimal/src/in_memory_minimal.rb

@@ -20,7 +20,7 @@ module Foobara
           # TODO: all multiple record methods should return enumerators and code further up should only use
           # the lazy enumerator interface... to encourage that/catch bugs we will return lazy enumerators in these
           # built-in crud drivers
-          def all
+          def all(page_size: nil)
             records.each_value.lazy
           end
 

data/projects/persistence/src/entity_attributes_crud_driver.rb

@@ -4,6 +4,12 @@ module Foobara
     class EntityAttributesCrudDriver
       attr_accessor :raw_connection, :tables
 
+      class << self
+        def has_real_transactions?
+          false
+        end
+      end
+
       def initialize(connection_or_credentials = nil)
         self.raw_connection = open_connection(connection_or_credentials)
         self.tables = {}
@@ -31,7 +37,7 @@ module Foobara
       def rollback_transaction(_raw_tx)
       end
 
-      def close_transaction(_raw_tx)
+      def commit_transaction(_raw_tx)
       end
 
       def table_for(entity_class)
@@ -91,7 +97,7 @@ module Foobara
           # :nocov:
         end
 
-        def all
+        def all(page_size: nil)
           # :nocov:
           raise "subclass responsibility"
           # :nocov:
@@ -161,39 +167,22 @@ module Foobara
 
         def matches_attributes_filter?(attributes, attributes_filter)
           attributes_filter.all? do |attribute_name_or_path, value|
-            value = normalize_attribute_filter_value(value)
+            # get the model-free type?
+            attribute_type = entity_class.attributes_type.type_at_path(attribute_name_or_path)
+
+            value = restore_attributes(value, attribute_type)
 
             if attribute_name_or_path.is_a?(::Array)
               values = DataPath.values_at(attribute_name_or_path, attributes)
 
               values.any? do |attribute_value|
-                normalize_attribute_filter_value(attribute_value) == value
+                restore_attributes(attribute_value, attribute_type) == value
               end
             else
-              attribute_value = attributes[attribute_name_or_path]
-              normalize_attribute_filter_value(attribute_value) == value
-            end
-          end
-        end
-
-        def normalize_attribute_filter_value(value)
-          case value
-          when ::Array
-            value.map { |v| normalize_attribute_filter_value(v) }
-          when ::Hash
-            value.to_h do |k, v|
-              [normalize_attribute_filter_value(k), normalize_attribute_filter_value(v)]
-            end
-          when DetachedEntity
-            if value.persisted?
-              normalize_attribute_filter_value(value.primary_key)
-            else
-              value
+              attribute_value = DataPath.value_at(attribute_name_or_path, attributes)
+              attribute_value = restore_attributes(attribute_value, attribute_type)
+              attribute_value == value
             end
-          when Model
-            normalize_attribute_filter_value(value.attributes)
-          else
-            value
           end
         end
 
@@ -262,6 +251,50 @@ module Foobara
         def primary_key_attribute
           entity_class.primary_key_attribute
         end
+
+        def restore_attributes(object, type = entity_class.attributes_type)
+          if type.extends?(BuiltinTypes[:attributes])
+            object.to_h do |attribute_name, attribute_value|
+              attribute_type = type.type_at_path(attribute_name)
+              [attribute_name.to_sym, restore_attributes(attribute_value, attribute_type)]
+            end
+          elsif type.extends?(BuiltinTypes[:tuple])
+            # TODO: test this code path
+            # :nocov:
+            object.map.with_index do |value, index|
+              element_type = type.element_types[index]
+              restore_attributes(value, element_type)
+            end
+            # :nocov:
+          elsif type.extends?(BuiltinTypes[:array])
+            element_type = type.element_type
+            object.map { |value| restore_attributes(value, element_type) }
+          elsif type.extends?(BuiltinTypes[:entity])
+            if object.is_a?(Model)
+              if object.persisted?
+                object = object.primary_key
+                restore_attributes(object, type.target_class.primary_key_type)
+              else
+                object
+              end
+            else
+              restore_attributes(object, type.target_class.primary_key_type)
+            end
+          elsif type.extends?(BuiltinTypes[:model])
+            if object.is_a?(Model)
+              object = object.attributes
+            end
+            restore_attributes(object, type.element_types)
+          else
+            outcome = type.process_value(object)
+
+            if outcome.success?
+              outcome.result
+            else
+              object
+            end
+          end
+        end
       end
     end
   end

data/projects/persistence/src/entity_base/transaction/concerns/state_transitions.rb

@@ -15,12 +15,20 @@ module Foobara
               end
             end
 
+            def open_nested!(outer_tx)
+              state_machine.open_nested! do
+                self.is_nested = true
+                self.raw_tx = outer_tx.raw_tx
+              end
+            end
+
             def flush!
               state_machine.flush! do
                 each_table(&:validate!)
                 each_table(&:flush_created!)
                 each_table(&:flush_updated_and_hard_deleted!)
               end
+              entity_attributes_crud_driver.flush_transaction(raw_tx)
             rescue => e
               # :nocov:
               rollback!(e)
@@ -34,6 +42,7 @@ module Foobara
               state_machine.revert! do
                 each_table(&:revert!)
               end
+              entity_attributes_crud_driver.revert_transaction(raw_tx)
             rescue => e
               # :nocov:
               rollback!(e)
@@ -42,11 +51,25 @@ module Foobara
             end
 
             def commit!
+              return commit_nested! if nested?
+
               state_machine.commit! do
-                each_table(&:validate!)
-                each_table(&:flush_created!)
-                each_table(&:flush_updated_and_hard_deleted!)
-                entity_attributes_crud_driver.close_transaction(raw_tx)
+                each_table(&:commit!)
+                entity_attributes_crud_driver.commit_transaction(raw_tx)
+                each_table(&:transaction_closed)
+              end
+            rescue => e
+              # :nocov:
+              rollback!(e)
+              raise
+              # :nocov:
+            end
+
+            def commit_nested!
+              state_machine.commit_nested! do
+                each_table(&:commit!)
+                entity_attributes_crud_driver.flush_transaction(raw_tx)
+                each_table(&:transaction_closed)
               end
             rescue => e
               # :nocov:
@@ -61,13 +84,32 @@ module Foobara
             end
 
             def rollback!(because_of = nil)
+              return rollback_nested!(because_of) if nested?
+
               state_machine.rollback! do
                 # TODO: raise error if already flushed and if crud_driver doesn't support true transactions
                 entity_attributes_crud_driver.rollback_transaction(raw_tx)
                 each_table(&:rollback!)
-                entity_attributes_crud_driver.close_transaction(raw_tx)
               end
 
+              each_table(&:transaction_closed)
+
+              if !because_of && (self == entity_base.current_transaction)
+                raise RolledBack, "intentionally rolled back"
+              end
+            rescue
+              state_machine.error! if state_machine.currently_open?
+              raise
+            end
+
+            def rollback_nested!(because_of = nil)
+              state_machine.rollback_nested! do
+                entity_attributes_crud_driver.revert_transaction(raw_tx)
+                each_table(&:revert!)
+              end
+
+              each_table(&:transaction_closed)
+
               if !because_of && (self == entity_base.current_transaction)
                 raise RolledBack, "intentionally rolled back"
               end

data/projects/persistence/src/entity_base/transaction/state_machine.rb

@@ -7,6 +7,7 @@ module Foobara
           set_transition_map({
                                unopened: {
                                  open: :open,
+                                 open_nested: :open,
                                  close: :closed
                                },
                                open: {
@@ -17,7 +18,9 @@ module Foobara
                                  # TODO: should we have intermediate states to quickly get out of the open state?
                                  rollback: :closed,
                                  commit: :closed,
-                                 error: :closed
+                                 error: :closed,
+                                 commit_nested: :closed,
+                                 rollback_nested: :closed
                                }
                              })
         end

data/projects/persistence/src/entity_base/transaction.rb

@@ -6,7 +6,7 @@ module Foobara
         include Concerns::EntityCallbackHandling
         include Concerns::TransactionTracking
 
-        attr_accessor :state_machine, :entity_base, :raw_tx, :tables
+        attr_accessor :state_machine, :entity_base, :raw_tx, :tables, :is_nested
 
         def initialize(entity_base)
           self.entity_base = entity_base
@@ -162,6 +162,10 @@ module Foobara
         def perform(&)
           entity_base.using_transaction(self, &)
         end
+
+        def nested?
+          is_nested
+        end
       end
     end
   end

data/projects/persistence/src/entity_base/transaction_table/concerns/record_tracking.rb

@@ -83,10 +83,25 @@ module Foobara
             end
 
             def rolled_back
+              closed
+            end
+
+            def committed
+              closed
+            end
+
+            def closed
               marked_hard_deleted.clear
               marked_updated.clear
               marked_created.clear
-              tracked_records.clear
+              marked_loading.clear
+            end
+
+            # We need to clear this one separately. That's because otherwise a different table
+            # might flush and create a thunk if it has an association to this table but we've stopped
+            # tracking the record.
+            def transaction_closed
+              tracked_records.close
             end
 
             def reverted

data/projects/persistence/src/entity_base/transaction_table.rb

@@ -632,6 +632,14 @@ module Foobara
           rolled_back
         end
 
+        def commit!
+          validate!
+          flush_created!
+          flush_updated_and_hard_deleted!
+
+          committed
+        end
+
         def revert!
           # TODO: could pause record tracking while doing this as a performance boost
           marked_updated.each(&:restore_without_callbacks!)

data/projects/persistence/src/entity_base.rb

@@ -52,7 +52,31 @@ module Foobara
         Thread.inheritable_thread_local_var_set(transaction_key, transaction)
       end
 
-      VALID_MODES = [:use_existing, :open_nested, :open_new, nil].freeze
+      # What types of transaction scenarios are there?
+      # 1. If a transaction is already open, use it as a "nested transaction", otherwise, open a new one.
+      #    A nested transaction means that "rollback" is the same as "revert" and "commit" is the same as "flush".
+      #    For a true
+      # 2. If a transaction is already open, raise an error. otherwise, open a new one.
+      # 3. Open a new, independent transaction, no matter what.
+      # 4. If a transaction is already open, use it, otherwise, open a new one.
+      # 5. We are outside of a transaction but have a handle on one. We want to set it as the current transaction.
+      #    and do some work in that transaction.
+      # Which use cases do we probably need at the moment?
+      # 1. If we are running a command calling other commands, we will open transactions when needed but
+      #    inherit any already-open transactions. Commands don't commit or flush to the already-open transactions
+      #    that they inherit. So this feels like a "use existing" situation or a situation where we don't even
+      #    bother calling open_transaction at all.  This is the most important use-case.  It can be helpful to raise
+      #    in this situation because it is not expected that there's an existing transaction yet we're opening another.
+      # 2. We might have a situation where we are in one transaction but definitely want to open a new one and
+      #    commit it ourselves and have its results committed and visible independent of the current transaction.
+      #    So this feels like a "open new" situation where we don't want to raise an error if a transaction is
+      #    already open.
+      VALID_MODES = [
+        :use_existing,
+        :open_nested,
+        :open_new,
+        nil
+      ].freeze
 
       def using_transaction(existing_transaction, &)
         transaction(existing_transaction:, &)
@@ -67,18 +91,28 @@ module Foobara
 
         old_transaction = current_transaction
 
-        if old_transaction&.closed?
+        if old_transaction && !old_transaction.currently_open?
           old_transaction = nil
         end
 
-        if old_transaction&.currently_open?
+        open_nested = false
+
+        if old_transaction
           if mode == :use_existing || existing_transaction == old_transaction
             if block_given?
               return yield old_transaction
             else
               return old_transaction
             end
-          elsif mode != :open_nested && mode != :open_new
+          elsif mode == :open_nested
+            open_nested = true
+          elsif mode == :open_new
+            if existing_transaction
+              # :nocov:
+              raise ArgumentError, "Cannot use mode :open_new with existing_transaction:"
+              # :nocov:
+            end
+          else
             # :nocov:
             raise "Transaction already open. " \
                   "Use mode :use_existing if you want to make use of the existing transaction. " \
@@ -96,16 +130,27 @@ module Foobara
             tx = existing_transaction
           else
             tx = Transaction.new(self)
-            tx.open!
+
+            if open_nested
+              tx.open_nested!(old_transaction)
+            else
+              tx.open!
+            end
           end
 
           set_current_transaction(tx)
+
           result = yield tx
-          tx.commit! if tx.currently_open? && !existing_transaction
+
+          if tx.currently_open? && !existing_transaction
+            tx.commit!
+          end
           result
         rescue Foobara::Persistence::EntityBase::Transaction::RolledBack # rubocop:disable Lint/SuppressedException
         rescue => e
-          tx.rollback!(e) if tx.currently_open?
+          if tx.currently_open?
+            tx.rollback!(e)
+          end
           raise
         ensure
           set_current_transaction(old_transaction)

data/projects/weak_object_set/src/weak_object_set.rb

@@ -4,8 +4,6 @@ module Foobara
   # TODO: a possible optimization: have a certain number of records before the Weakref approach kicks in
   # that way we don't just immediately clear out useful information without any actual memory burden
   class WeakObjectSet
-    class InvalidWtf < StandardError; end
-
     class GarbageCleaner
       attr_accessor :weak_object_set, :deactivated, :queue, :cleanup_thread
 
@@ -17,6 +15,12 @@ module Foobara
       end
 
       def cleanup_proc
+        if deactivated?
+          # :nocov:
+          raise "GarbageCleaner has been deactivated"
+          # :nocov:
+        end
+
         @cleanup_proc ||= begin
           queue = self.queue
 
@@ -35,6 +39,8 @@ module Foobara
       end
 
       def start_cleanup_thread
+        queue = self.queue
+
         self.cleanup_thread = Thread.new do
           loop do
             object_id = queue.pop
@@ -57,9 +63,16 @@ module Foobara
       end
 
       def deactivate
+        raise if deactivated?
+
         self.deactivated = true
         queue.close
+        # TODO: don't bother to join here outside of test suite
         cleanup_thread.join # just doing this for test suite/simplecov
+        @cleanup_proc = nil
+        @queue = nil
+        @weak_object_set = nil
+        @cleanup_thread = nil
       end
 
       def deactivated?
@@ -69,7 +82,7 @@ module Foobara
 
     include Enumerable
 
-    attr_accessor :monitor, :key_method, :key_to_object_id, :object_id_to_key, :objects
+    attr_accessor :monitor, :key_method, :key_to_object_id, :object_id_to_key, :objects, :closed
     attr_writer :garbage_cleaner
 
     def initialize(key_method = nil)
@@ -136,19 +149,17 @@ module Foobara
       @garbage_cleaner ||= begin
         queue = Queue.new
 
-        gc = GarbageCleaner.new(self, queue)
-
-        ObjectSpace.define_finalizer gc do
-          # :nocov:
-          queue.close
-          # :nocov:
-        end
-
-        gc
+        GarbageCleaner.new(self, queue)
       end
     end
 
     def <<(object)
+      if closed?
+        # :nocov:
+        raise "Cannot add objects to a closed WeakObjectSet"
+        # :nocov:
+      end
+
       object_id = object.object_id
 
       monitor.synchronize do
@@ -235,11 +246,30 @@ module Foobara
       end
     end
 
+    def close
+      raise if closed?
+
+      self.closed = true
+      stop_garbage_cleaner
+    end
+
+    def stop_garbage_cleaner
+      gc = nil
+
+      monitor.synchronize do
+        if @garbage_cleaner
+          gc = garbage_cleaner
+          self.garbage_cleaner = nil
+        end
+      end
+
+      gc&.deactivate
+    end
+
     def clear
       monitor.synchronize do
-        garbage_cleaner.deactivate
+        stop_garbage_cleaner
 
-        self.garbage_cleaner = nil
         self.objects = {}
 
         if key_method
@@ -248,5 +278,9 @@ module Foobara
         end
       end
     end
+
+    def closed?
+      closed
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foobara
 version: !ruby/object:Gem::Version
-  version: 0.0.130
+  version: 0.0.131
 platform: ruby
 authors:
 - Miles Georgi
@@ -486,8 +486,8 @@ licenses:
 - MPL-2.0
 metadata:
   homepage_uri: https://foobara.com
-  source_code_uri: https://foobara.com
-  changelog_uri: https://foobara.com/blob/main/CHANGELOG.md
+  source_code_uri: https://github.com/foobara/foobara
+  changelog_uri: https://github.com/foobara/foobara/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
@@ -529,7 +529,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.6.9
 specification_version: 4
 summary: A command-centric and discoverable software framework with a focus on domain
   concepts and abstracting away integration code