foobara 0.1.13 → 0.1.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1261fd639b27af7af53e6a9be2225216d27ac77a83bddf4d78d645102473bff6
-  data.tar.gz: 8d1c16370a2adfdbd9eb47126d1ab830b502c2b7dfa885ed9099d0851a9bcd60
+  metadata.gz: 8dd944e7f4507fadcfec80d3a79c7050f3cdce69b5dddbc7869183e865e0e1fc
+  data.tar.gz: a5b8bead81dabbc63f239f9c51ef792f9a8e536f516266bd0c79a5ab05ed38b4
 SHA512:
-  metadata.gz: b5a6ef53e71864b9d756447f8eaae461e798d243c23121e041a12a6e0c4ecaa87b624c593d185549b2714569b965913447fa747e5df7922d8a538d1a60061b94
-  data.tar.gz: 5a45569f70560c505b4c61a44fc91a0145e9d362c1f07ecacc2fb7cdbc3bbf12b9bc1f35ea51996f6138d060ed09b236483ed88fe12886609d3e241624db451a
+  metadata.gz: ac1a42bcc81cfdabfdb7b8af603f4992c273cf14ac58b974d03ec0e1cec4f997234e4a80ddd5bdfee016448c354c4f5e3b6fafff66282922b51e9fce8c94f609
+  data.tar.gz: c728063369dd04a29c30fa13a98a15c47ecf896b49ab920091c70dfebecc054c9df7a21674069e3873de628884a31e020bc33f0c64bfd156dca7206de92ef578

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+# [0.1.15] - 2025-10-02
+
+- Make some more methods private
+- Clear transformed command class cache and entity class paths cache on Namespace changes
+- Implement Namespace.on_change
+- Add WeakObjectHash project
+- Remove command-named function concept and Command@all
+- Don't store all domain modules created, allowing more garbage collection
+
+# [0.1.14] - 2025-09-27
+
+- When using aggregate/atom_entities connector options, remove default serializer/pre-commit transformers of the other
+
 # [0.1.13] - 2025-09-27
 
 - Fix various bugs resulting in values missing from connector manifest or included when they should not be

data/projects/command/lib/foobara/command.rb

@@ -7,31 +7,6 @@ module Foobara
       def install!
         Namespace.global.foobara_add_category_for_subclass_of(:command, self)
       end
-
-      def reset_all
-        Foobara.raise_if_production!("reset_all")
-        to_delete = []
-
-        all.each do |command_class|
-          if command_class.name.include?("::")
-            parent_name = Util.parent_module_name_for(command_class.name)
-
-            if Object.const_defined?(parent_name)
-              command_class.undefine_command_named_function
-            else
-              to_delete << command_class
-            end
-          else
-            command_class.undefine_command_named_function
-          end
-        end
-
-        to_delete.each do |command_class|
-          all.delete(command_class)
-        end
-
-        super
-      end
     end
   end
 end

data/projects/command/src/command.rb

@@ -1,7 +1,5 @@
 module Foobara
   class Command
     include CommandPatternImplementation
-    # Maybe make ShortcutForRun optional and maybe even move it to a different repository?
-    include Concerns::ShortcutForRun
   end
 end

data/projects/command/src/command_pattern_implementation/concerns/callbacks.rb

@@ -6,19 +6,7 @@ module Foobara
       module Callbacks
         include Concern
 
-        inherited_overridable_class_attr_accessor :subclass_defined_callbacks
-
         module ClassMethods
-          def inherited(subclass)
-            super
-
-            subclass_defined_callbacks.runner.callback_data(subclass).run
-          end
-
-          def after_subclass_defined(&)
-            subclass_defined_callbacks.register_callback(:after, &)
-          end
-
           def state_machine_callback_registry
             return @state_machine_callback_registry if defined?(@state_machine_callback_registry)
 
@@ -100,10 +88,6 @@ module Foobara
         def state_machine_callback_registry
           state_machine.callback_registry
         end
-
-        on_include do
-          self.subclass_defined_callbacks ||= Foobara::Callback::Registry::SingleAction.new
-        end
       end
     end
   end

data/projects/command/src/command_pattern_implementation/concerns/entities.rb

@@ -21,7 +21,6 @@ module Foobara
           end
 
           def entity_class_paths
-            # TODO: bust this cache when changing inputs_type??
             @entity_class_paths ||= Entity.construct_associations(
               inputs_type
             ).transform_values(&:target_class)

data/projects/command/src/command_pattern_implementation/concerns/inputs_type.rb

@@ -16,6 +16,10 @@ module Foobara
               remove_instance_variable(:@inputs_association_paths)
             end
 
+            if defined?(@entity_class_paths)
+              remove_instance_variable(:@entity_class_paths)
+            end
+
             type = type_for_declaration(...)
 
             if type.extends?(BuiltinTypes[:model]) && !type.extends?(BuiltinTypes[:entity])

data/projects/command/src/command_pattern_implementation/concerns/reflection.rb

@@ -5,21 +5,7 @@ module Foobara
         include Concern
         include Manifestable
 
-        def initialize(...)
-          self.class.all << self
-          super
-        end
-
         module ClassMethods
-          def all
-            @all ||= []
-          end
-
-          def reset_all
-            Foobara.raise_if_production!("reset_all")
-            remove_instance_variable("@all") if instance_variable_defined?("@all")
-          end
-
           def foobara_manifest
             to_include = TypeDeclarations.foobara_manifest_context_to_include
 

data/projects/command/src/command_pattern_implementation/concerns/runtime.rb

@@ -74,6 +74,12 @@ module Foobara
           outcome&.success?
         end
 
+        def halt!
+          raise Halt
+        end
+
+        private
+
         def run_execute
           self.raw_result = execute
           result = process_result_using_result_type(raw_result)
@@ -129,12 +135,6 @@ module Foobara
           # can override if desired, default is a no-op
         end
 
-        def halt!
-          raise Halt
-        end
-
-        private
-
         def invoke_with_callbacks_and_transition_in_transaction(transition_or_transitions)
           Persistence::EntityBase.using_transactions(transactions) do
             invoke_with_callbacks_and_transition(transition_or_transitions)

data/projects/command/src/command_pattern_implementation/concerns/subcommands.rb

@@ -16,6 +16,8 @@ module Foobara
           is_subcommand
         end
 
+        private
+
         def run_subcommand!(subcommand_class, inputs = {})
           domain = self.class.domain
           sub_domain = subcommand_class.domain

data/projects/command_connectors/src/command_registry/exposed_command.rb

@@ -58,12 +58,16 @@ module Foobara
         if aggregate_entities
           pre_commit_transformers = [
             *pre_commit_transformers,
-            Foobara::CommandConnectors::Transformers::LoadAggregatesPreCommitTransformer
-          ].uniq
-          serializers = [
-            *serializers,
-            Foobara::CommandConnectors::Serializers::AggregateSerializer
-          ].uniq
+            CommandConnectors::Transformers::LoadAggregatesPreCommitTransformer
+          ]
+
+          pre_commit_transformers.uniq!
+          pre_commit_transformers.delete(CommandConnectors::Transformers::LoadAtomsPreCommitTransformer)
+
+          serializers = [*serializers, CommandConnectors::Serializers::AggregateSerializer]
+
+          serializers.uniq!
+          serializers.delete(Foobara::CommandConnectors::Serializers::AtomicSerializer)
         # TODO: either both should have special behavior for false or neither should
         elsif aggregate_entities == false
           pre_commit_transformers = pre_commit_transformers&.reject do |t|
@@ -73,7 +77,18 @@ module Foobara
             s == Foobara::CommandConnectors::Serializers::AggregateSerializer
           end
         elsif atomic_entities
-          serializers = [*serializers, Foobara::CommandConnectors::Serializers::AtomicSerializer].uniq
+          pre_commit_transformers = [
+            *pre_commit_transformers,
+            CommandConnectors::Transformers::LoadAtomsPreCommitTransformer
+          ]
+
+          pre_commit_transformers.uniq!
+          pre_commit_transformers.delete(CommandConnectors::Transformers::LoadAggregatesPreCommitTransformer)
+
+          serializers = [*serializers, Foobara::CommandConnectors::Serializers::AtomicSerializer]
+
+          serializers.uniq!
+          serializers.delete(CommandConnectors::Serializers::AggregateSerializer)
         end
 
         self.command_class = command_class
@@ -98,9 +113,17 @@ module Foobara
             self.pre_commit_transformers = [
               *self.pre_commit_transformers,
               CommandConnectors::Transformers::LoadDelegatedAttributesEntitiesPreCommitTransformer
-            ].uniq
+            ]
+
+            pre_commit_transformers.uniq!
           end
         end
+
+        Namespace.on_change(self, :clear_caches)
+      end
+
+      def clear_caches
+        @transformed_command_class = nil
       end
 
       def _has_delegated_attributes?(type)

data/projects/domain/src/domain_module_extension.rb

@@ -12,10 +12,6 @@ module Foobara
 
     module DomainModuleExtension
       class << self
-        def all
-          @all ||= []
-        end
-
         # TODO: rename this
         def _copy_constants(old_mod, new_class)
           old_mod.constants.each do |const_name|
@@ -55,10 +51,6 @@ module Foobara
       include Concern
       include Manifestable
 
-      on_include do
-        DomainModuleExtension.all << self
-      end
-
       module ClassMethods
         attr_writer :foobara_domain_name, :foobara_full_domain_name
 

data/projects/foobara/lib/foobara/all.rb

@@ -16,7 +16,7 @@ module Foobara
   # could be independent projects
   projects "delegate", # Let's just kill delegate
            "concerns",
-           "weak_object_set",
+           "weak_object_hash",
            "enumerated",
            "callback",
            "state_machine",
@@ -34,6 +34,8 @@ module Foobara
            "model",
            "detached_entity",
            "entity",
+           # only used by entity persistence so loading it here
+           "weak_object_set",
            "persistence",
            "nested_transactionable",
            "model_attribute_helpers",

data/projects/namespace/src/is_namespace.rb

@@ -114,6 +114,8 @@ module Foobara
         # TODO: do we really need to clear the whole cache? Why not just the possible
         # impacted keys based on scoped.scoped_path ?
         Namespace.clear_lru_cache!
+        Namespace.fire_changed!
+
         if scoped.unregistered_foobara_manifest_reference
           scoped.unregistered_foobara_manifest_reference = nil
         end
@@ -139,6 +141,7 @@ module Foobara
         scoped.scoped_unregistered!
 
         Namespace.clear_lru_cache!
+        Namespace.fire_changed!
       end
 
       def foobara_unregister_all
@@ -148,7 +151,7 @@ module Foobara
       end
 
       def lru_cache
-        Namespace.lru_cache
+        @lru_cache ||= Namespace.lru_cache
       end
 
       def foobara_lookup(path, filter: nil, mode: LookupMode::GENERAL)

data/projects/namespace/src/namespace.rb

@@ -50,14 +50,24 @@ module Foobara
         end
       end
 
+      def on_change(object, method_name)
+        @on_change ||= WeakObjectHash.new
+
+        @on_change[object] = method_name
+      end
+
+      def fire_changed!
+        @on_change&.each_pair do |object, method_name|
+          object.send(method_name)
+        end
+      end
+
       def lru_cache
         @lru_cache ||= Foobara::LruCache.new(1000)
       end
 
       def clear_lru_cache!
-        if @lru_cache
-          lru_cache.reset!
-        end
+        @lru_cache&.reset!
       end
     end
 

data/projects/type_declarations/lib/foobara/type_declarations.rb

@@ -6,15 +6,6 @@ module Foobara
           Foobara.raise_if_production!("reset_all")
         end
 
-        # TODO: this doesn't really belong here. I think we need to maybe call reset in reverse order?
-        Foobara::Domain::DomainModuleExtension.all.each do |domain|
-          var = "@foobara_type_builder"
-
-          if domain.instance_variable_defined?(var)
-            domain.remove_instance_variable(var)
-          end
-        end
-
         Util.descendants(Error).each do |error_class|
           if error_class.instance_variable_defined?(:@context_type)
             error_class.remove_instance_variable(:@context_type)

data/projects/type_declarations/src/type_builder.rb

@@ -155,7 +155,9 @@ module Foobara
       private
 
       def lru_cache
-        Namespace.lru_cache
+        @lru_cache ||= Foobara::LruCache.new(100).tap do |cache|
+          Namespace.on_change(cache, :reset!)
+        end
       end
     end
   end

data/projects/weak_object_hash/lib/foobara/weak_object_hash.rb

@@ -0,0 +1,3 @@
+require "weakref"
+
+class Foobara::WeakObjectHash; end

data/projects/weak_object_hash/src/weak_object_hash.rb

@@ -0,0 +1,225 @@
+require "monitor"
+
+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 WeakObjectHash
+    class ClosedError < StandardError; end
+
+    def initialize(skip_finalizer: false)
+      if skip_finalizer
+        self.skip_finalizer = true
+      end
+      self.monitor = Monitor.new
+      self.object_ids_to_weak_refs_and_values = {}
+    end
+
+    def []=(object, value)
+      object_id = object.object_id
+      weak_ref = WeakRef.new(object)
+
+      if closed?
+        raise ClosedError, "Cannot add objects to a closed WeakObjectHash"
+      end
+
+      monitor.synchronize do
+        delete(object)
+
+        object_ids_to_weak_refs_and_values[object_id] = [weak_ref, value]
+
+        unless skip_finalizer?
+          ObjectSpace.define_finalizer(object, finalizer_proc)
+        end
+
+        value
+      end
+    end
+
+    def [](object)
+      object_id = object.object_id
+
+      if closed?
+        raise ClosedError, "Cannot retrieve objects from a closed WeakObjectHash"
+      end
+
+      monitor.synchronize do
+        pair = object_ids_to_weak_refs_and_values[object_id]
+
+        return nil unless pair
+
+        weak_ref, value = pair
+
+        if weak_ref.weakref_alive?
+          if skip_finalizer?
+            if weak_ref.__getobj__ == object
+              value
+            else
+              # :nocov:
+              object_ids_to_weak_refs_and_values.delete(object_id)
+              nil
+              # :nocov:
+            end
+          else
+            value
+          end
+        else
+          # Seems unreachable... if it's been garbage collected how could we have a reference to the object
+          # to pass it in?
+          # :nocov:
+          object_ids_to_weak_refs_and_values.delete(object_id)
+          nil
+          # :nocov:
+        end
+      end
+    end
+
+    def delete(object)
+      object_id = object.object_id
+
+      monitor.synchronize do
+        pair = object_ids_to_weak_refs_and_values.delete(object_id)
+
+        return nil unless pair
+
+        weak_ref, value = pair
+
+        if weak_ref.weakref_alive?
+
+          if skip_finalizer?
+            if weak_ref.__getobj__ == object
+              value
+            end
+          else
+            # Hmmm, there's seemingly no safe way to remove the finalizer for the previous entry
+            # if it exists. This is because we can only remove all finalizers on object. Not only
+            # the ones we've created.
+            # We will just do this anyway with that caveat and maybe make this configuratble in the future.
+            unless skip_finalizer?
+              ObjectSpace.undefine_finalizer(object)
+            end
+
+            value
+          end
+        end
+      end
+    end
+
+    def each_pair
+      monitor.synchronize do
+        object_ids_to_weak_refs_and_values.each_pair do |object_id, pair|
+          weak_ref, value = pair
+
+          if weak_ref.weakref_alive?
+            yield weak_ref.__getobj__, value
+          else
+            object_ids_to_weak_refs_and_values.delete(object_id)
+          end
+        end
+      end
+
+      self
+    end
+
+    def values
+      values = []
+
+      monitor.synchronize do
+        each_pair do |_key, value|
+          values << value
+        end
+      end
+
+      values
+    end
+
+    def keys
+      keys = []
+
+      monitor.synchronize do
+        each_pair do |key, _value|
+          keys << key
+        end
+      end
+
+      keys
+    end
+
+    def size
+      size = 0
+      to_delete = nil
+
+      monitor.synchronize do
+        object_ids_to_weak_refs_and_values.each_pair do |object_id, pair|
+          weak_ref = pair.first
+
+          if weak_ref.weakref_alive?
+            size += 1
+          else
+            to_delete ||= []
+            to_delete << object_id
+          end
+        end
+
+        to_delete&.each do |object_id|
+          object_ids_to_weak_refs_and_values.delete(object_id)
+        end
+      end
+
+      size
+    end
+
+    def empty?
+      size == 0
+    end
+
+    def close!
+      if closed?
+        raise ClosedError, "Already closed"
+      end
+
+      monitor.synchronize do
+        self.closed = true
+        clear
+        @finalizer_proc = nil
+        self.object_ids_to_weak_refs_and_values = nil
+        self.monitor = nil
+      end
+    end
+
+    def clear
+      monitor.synchronize do
+        unless skip_finalizer?
+          object_ids_to_weak_refs_and_values.each_value do |pair|
+            weak_ref = pair.first
+
+            if weak_ref.weakref_alive?
+              ObjectSpace.undefine_finalizer(weak_ref.__getobj__)
+            end
+          end
+        end
+
+        object_ids_to_weak_refs_and_values.clear
+      end
+    end
+
+    def closed?
+      closed
+    end
+
+    def skip_finalizer?
+      @skip_finalizer
+    end
+
+    private
+
+    attr_accessor :object_ids_to_weak_refs_and_values, :monitor, :closed, :skip_finalizer
+
+    def finalizer_proc
+      @finalizer_proc ||= ->(object_id) do
+        unless closed?
+          object_ids_to_weak_refs_and_values.delete(object_id)
+        end
+      end
+    end
+  end
+end

data/projects/weak_object_set/src/weak_object_set.rb

@@ -56,6 +56,8 @@ module Foobara
             end
           end
         end
+
+        cleanup_thread.priority = -2
       end
 
       def track(object)
@@ -68,7 +70,7 @@ module Foobara
         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_thread.join if ENV["FOOBARA_ENV"] == "test" # just doing this for test suite/simplecov
         @cleanup_proc = nil
         @queue = nil
         @weak_object_set = nil

data/version.rb

@@ -1,6 +1,6 @@
 module Foobara
   module Version
-    VERSION = "0.1.13".freeze
+    VERSION = "0.1.15".freeze
     MINIMUM_RUBY_VERSION = ">= 3.4.0".freeze
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foobara
 version: !ruby/object:Gem::Version
-  version: 0.1.13
+  version: 0.1.15
 platform: ruby
 authors:
 - Miles Georgi
@@ -162,7 +162,6 @@ files:
 - projects/callback/src/set.rb
 - projects/command/lib/foobara/command.rb
 - projects/command/src/command.rb
-- projects/command/src/command/concerns/shortcut_for_run.rb
 - projects/command/src/command_pattern_implementation.rb
 - projects/command/src/command_pattern_implementation/concerns/callbacks.rb
 - projects/command/src/command_pattern_implementation/concerns/description.rb
@@ -491,6 +490,8 @@ files:
 - projects/value/src/processor/selection.rb
 - projects/value/src/transformer.rb
 - projects/value/src/validator.rb
+- projects/weak_object_hash/lib/foobara/weak_object_hash.rb
+- projects/weak_object_hash/src/weak_object_hash.rb
 - projects/weak_object_set/lib/foobara/weak_object_set.rb
 - projects/weak_object_set/src/weak_object_set.rb
 - version.rb
@@ -529,6 +530,7 @@ require_paths:
 - "./projects/type_declarations/lib"
 - "./projects/types/lib"
 - "./projects/value/lib"
+- "./projects/weak_object_hash/lib"
 - "./projects/weak_object_set/lib"
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:

data/projects/command/src/command/concerns/shortcut_for_run.rb

@@ -1,64 +0,0 @@
-module Foobara
-  class Command
-    module Concerns
-      module ShortcutForRun
-        include Concern
-
-        on_include do
-          Command.after_subclass_defined do |subclass|
-            Command.all << subclass
-            # This results in being able to use the command class name instead of .run! if you want.
-            # So instead of DoIt.run!(inputs) you can just do DoIt(inputs)
-            # TODO: can we kill this? I don't think anything uses this nor would really need to.
-            # Calling code could define such helper methods if desired but could be a bad idea since it is nice for
-            # command calls to stick out as command calls which would be less obvious if they just looked like random
-            # method calls (except that they are class case instead of underscore case)
-            subclass.define_command_named_function
-          end
-        end
-
-        module ClassMethods
-          def define_command_named_function
-            return if name.nil?
-
-            command_class = self
-            convenience_method_name = Foobara::Util.non_full_name(command_class)
-            containing_module = Foobara::Util.module_for(command_class) || Object
-
-            if containing_module.is_a?(::Class)
-              containing_module.singleton_class.define_method convenience_method_name do |*args, **opts, &block|
-                command_class.run!(*args, **opts, &block)
-              end
-
-              containing_module.define_method convenience_method_name do |*args, **opts, &block|
-                command_class.run!(*args, **opts, &block)
-              end
-            else
-              containing_module.module_eval do
-                module_function
-
-                define_method convenience_method_name do |*args, **opts, &block|
-                  command_class.run!(*args, **opts, &block)
-                end
-              end
-            end
-          end
-
-          def undefine_command_named_function
-            command_class = self
-            convenience_method_name = Foobara::Util.non_full_name(command_class)
-            containing_module = Foobara::Util.module_for(command_class) || Object
-
-            return unless containing_module.respond_to?(convenience_method_name)
-
-            containing_module.singleton_class.undef_method convenience_method_name
-
-            if containing_module.is_a?(::Class)
-              containing_module.undef_method convenience_method_name
-            end
-          end
-        end
-      end
-    end
-  end
-end