foobara 0.0.135 → 0.0.137

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0560b5378293e0abf5477c545b37e05646ffd31e90160e60dd9f9e107e5307f5
-  data.tar.gz: 1b56363410e7a2af706f001559ee7a43c9ba27683b7a2de163747c8645054e5a
+  metadata.gz: 4c5acf1ac653d427d77720c273fa25651b6865482733f8b0a382a6cf5af9a2cd
+  data.tar.gz: ea8cf9b48ecc319a63d2d373339b729de4ee28763a85d30a31d8e1faf50faf08
 SHA512:
-  metadata.gz: c3af812dd4decf50d37a5080d52299aa6eafe1643846ea92e73fa1acc6bc535f6772e8cb56356fad3065ec3b0dda1ed6be695f0fb826f9fd8cf9956014dd06af
-  data.tar.gz: 8cafe756d10ed613cdb4da5e521a37f8e1c8cd8c40738744898224ff4cb5aadf244ac92c81f9aa608b1666debcd72a3c2ca6776262f2a4d649524dc2f8f2b4b9
+  metadata.gz: ab129e2a8bcaca2e72aa7c1208197586af9563c4540c3ba6b7925e0ae1fafb20a31fa9ea523b4906215b779aab265736b46f3c13ced24a74a63ff6466502ed0e
+  data.tar.gz: e2fcb02c9a104085488983a3e4755557696b83a5bd6353ffd35b562132e93a3f58871a175c2e8d126ba119ded2bc5eb36a4a0098fffc979632fc7bef84c08290

data/CHANGELOG.md

@@ -1,3 +1,19 @@
+# [0.0.137] - 2025-07-22
+
+- Fix bug where update_children_with_new_parent processes a scoped with itself
+- Don't double-create Reject inputs transformers
+- Fix description bug when transforming an entity to its primary key type
+- Add .raise_if_production method to all uses of reset_all(s)
+- Move the start_with? method another repository
+- Prevent attributes transformers without attributes
+
+# [0.0.136] - 2025-07-06
+
+- Do not allow calling Foobara.reset_alls in production
+- Fix an error backtrace bug
+- Separate Atom/Aggregate request versus object behavior in precommit transformers
+- Fix busted command-class-level state machine callbacks
+
 # [0.0.135] - 2025-07-01
 
 - Eliminate Monorepo project

data/projects/builtin_types/lib/foobara/builtin_types.rb

@@ -64,6 +64,7 @@ module Foobara
       end
 
       def reset_all
+        Foobara.raise_if_production!("reset_all")
         builtin_types.each do |builtin_type|
           builtin_type.foobara_each do |scoped|
             if scoped.scoped_namespace == builtin_type

data/projects/callback/src/registry/chained_conditioned.rb

@@ -1,4 +1,4 @@
-Foobara.require_project_file("callback", "registry/conditioned")
+require_relative "joined_conditioned"
 
 module Foobara
   module Callback
@@ -6,8 +6,6 @@ module Foobara
       class ChainedConditioned < Conditioned
         attr_accessor :other_conditions_registry
 
-        class InvalidConditions < StandardError; end
-
         foobara_delegate :possible_conditions, :possible_condition_keys, to: :other_conditions_registry
 
         def initialize(other_conditions_registry)

data/projects/callback/src/registry/joined_conditioned.rb

@@ -0,0 +1,28 @@
+require_relative "conditioned"
+
+module Foobara
+  module Callback
+    module Registry
+      class JoinedConditioned < Conditioned
+        attr_accessor :first, :second
+
+        foobara_delegate :possible_conditions, :possible_condition_keys, to: :first
+
+        def initialize(first, second)
+          self.first = first
+          self.second = second
+
+          super(possible_conditions)
+        end
+
+        def unioned_callback_set_for(...)
+          super.union(
+            first.unioned_callback_set_for(...).union(
+              second.unioned_callback_set_for(...)
+            )
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -9,6 +9,7 @@ module Foobara
       end
 
       def reset_all
+        Foobara.raise_if_production!("reset_all")
         to_delete = []
 
         all.each do |command_class|

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

@@ -1,3 +1,5 @@
+require_relative "../../state_machine"
+
 module Foobara
   module CommandPatternImplementation
     module Concerns
@@ -17,75 +19,90 @@ module Foobara
             subclass_defined_callbacks.register_callback(:after, &)
           end
 
-          def callback_state_machine_target
-            Foobara::Command::StateMachine
+          def state_machine_callback_registry
+            return @state_machine_callback_registry if defined?(@state_machine_callback_registry)
+
+            @state_machine_callback_registry = if superclass.respond_to?(:state_machine_callback_registry)
+                                                 Callback::Registry::ChainedConditioned.new(
+                                                   superclass.state_machine_callback_registry
+                                                 )
+                                               else
+                                                 Callback::Registry::Conditioned.new(
+                                                   from: Foobara::Command::StateMachine.states,
+                                                   transition: Foobara::Command::StateMachine.transitions,
+                                                   to: Foobara::Command::StateMachine.states
+                                                 )
+                                               end
           end
 
-          foobara_delegate :remove_all_callbacks, to: :callback_state_machine_target
+          def remove_all_callbacks
+            Foobara::Command::StateMachine.remove_all_callbacks
+            if defined?(@state_machine_callback_registry)
+              remove_instance_variable(:@state_machine_callback_registry)
+            end
+          end
         end
 
-        on_include do
-          self.subclass_defined_callbacks ||= Foobara::Callback::Registry::SingleAction.new
-
-          [self, singleton_class].each do |target|
-            [:before, :after].each do |type|
-              target.define_method "#{type}_any_transition" do |&block|
-                callback_state_machine_target.register_transition_callback(type) do |state_machine:, **args|
-                  block.call(command: state_machine.owner, **args)
-                end
+        [self, ClassMethods].each do |target|
+          [:before, :after].each do |type|
+            target.define_method "#{type}_any_transition" do |&block|
+              state_machine_callback_registry.register_callback(type) do |state_machine:, **args|
+                block.call(command: state_machine.owner, **args)
               end
             end
+          end
 
-            target.define_method "around_any_transition" do |&block|
-              callback_state_machine_target.register_transition_callback(
-                :around
-              ) do |state_machine:, **args, &do_transition_block|
-                block.call(command: state_machine.owner, **args, &do_transition_block)
-              end
+          target.define_method "around_any_transition" do |&block|
+            state_machine_callback_registry.register_callback(
+              :around
+            ) do |state_machine:, **args, &do_transition_block|
+              block.call(command: state_machine.owner, **args, &do_transition_block)
             end
+          end
 
-            target.define_method :error_any_transition do |&block|
-              callback_state_machine_target.register_transition_callback(:error) do |error|
-                callback_data = error.callback_data
+          target.define_method :error_any_transition do |&block|
+            state_machine_callback_registry.register_callback(:error) do |error|
+              callback_data = error.callback_data
 
-                state_machine = callback_data[:state_machine]
-                command = state_machine.owner
-                from = callback_data[:from]
-                transition = callback_data[:transition]
-                to = callback_data[:to]
+              state_machine = callback_data[:state_machine]
+              command = state_machine.owner
+              from = callback_data[:from]
+              transition = callback_data[:transition]
+              to = callback_data[:to]
 
-                block.call(error:, command:, state_machine:, from:, to:, transition:)
-              end
+              block.call(error:, command:, state_machine:, from:, to:, transition:)
             end
           end
+        end
 
-          Foobara::Command::StateMachine.transitions.each do |transition|
-            [self, singleton_class].each do |target|
-              [:before, :after].each do |type|
-                target.define_method "#{type}_#{transition}" do |&block|
-                  callback_state_machine_target.register_transition_callback(
-                    type, transition:
-                  ) do |state_machine:, **args|
-                    block.call(command: state_machine.owner, **args)
-                  end
+        Foobara::Command::StateMachine.transitions.each do |transition|
+          [self, ClassMethods].each do |target|
+            [:before, :after].each do |type|
+              target.define_method "#{type}_#{transition}" do |&block|
+                state_machine_callback_registry.register_callback(
+                  type, transition:
+                ) do |state_machine:, **args|
+                  block.call(command: state_machine.owner, **args)
                 end
               end
+            end
 
-              target.define_method "around_#{transition}" do |&block|
-                callback_state_machine_target.register_transition_callback(
-                  :around, transition:
-                ) do |state_machine:, **args, &do_transition_block|
-                  block.call(command: state_machine.owner, **args, &do_transition_block)
-                end
+            target.define_method "around_#{transition}" do |&block|
+              state_machine_callback_registry.register_callback(
+                :around, transition:
+              ) do |state_machine:, **args, &do_transition_block|
+                block.call(command: state_machine.owner, **args, &do_transition_block)
               end
             end
           end
         end
 
-        private
+        def state_machine_callback_registry
+          state_machine.callback_registry
+        end
 
-        def callback_state_machine_target
-          state_machine
+        on_include do
+          self.subclass_defined_callbacks ||= Foobara::Callback::Registry::SingleAction.new
         end
       end
     end

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

@@ -16,6 +16,7 @@ module Foobara
           end
 
           def reset_all
+            Foobara.raise_if_production!("reset_all")
             remove_instance_variable("@all") if instance_variable_defined?("@all")
           end
 

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

@@ -3,8 +3,17 @@ module Foobara
     module Concerns
       module StateMachine
         def state_machine
+          return @state_machine if defined?(@state_machine)
+
           # It makes me nervous to pass self around. Seems like a design smell.
-          @state_machine ||= Foobara::Command::StateMachine.new(owner: self)
+          @state_machine = Foobara::Command::StateMachine.new(owner: self)
+
+          @state_machine.callback_registry = Callback::Registry::JoinedConditioned.new(
+            @state_machine.callback_registry,
+            self.class.state_machine_callback_registry
+          )
+
+          @state_machine
         end
       end
     end

data/projects/command_connectors/lib/foobara/command_connectors.rb

@@ -24,6 +24,7 @@ module Foobara
       end
 
       def reset_all
+        Foobara.raise_if_production!("reset_all")
         remove_instance_variable("@desugarizer") if defined?(@desugarizer)
         remove_instance_variable("@desugarizers") if defined?(@desugarizers)
       end

data/projects/command_connectors/src/serializers/errors_serializer.rb

@@ -11,8 +11,7 @@ module Foobara
         end
 
         def serialize(error_collection)
-          errors = error_collection.errors
-          errors.map(&:to_h)
+          error_collection.map(&:to_h)
         end
       end
     end

data/projects/command_connectors/src/transformed_command.rb

@@ -1,6 +1,5 @@
 module Foobara
   # TODO: feels so strange that this doesn't inherit from command
-  # TODO: move this to command connectors project
   class TransformedCommand
     class << self
       # TODO: handle errors_transformers!
@@ -752,7 +751,6 @@ module Foobara
       self.outcome = outcome if outcome
     rescue => e
       if capture_unknown_error
-        # TODO: move to superclass?
         self.outcome = Outcome.error(CommandConnector::UnknownError.for(e))
       else
         # :nocov:

data/projects/command_connectors/src/transformers/entity_to_primary_key_inputs_transformer.rb

@@ -52,13 +52,19 @@ module Foobara
 
               unless to_type.extends_directly?(Foobara::BuiltinTypes[:detached_entity]) ||
                      to_type.extends_directly?(Foobara::BuiltinTypes[:entity])
+
                 description = [
                   description,
-                  to_type.description
+                  *to_type.description
                 ].join(" : ")
               end
+
               declaration[:description] = description
 
+              if to_type.declaration_data.key?(:allow_nil)
+                declaration[:allow_nil] = to_type.declaration_data[:allow_nil]
+              end
+
               declaration
             elsif to_type.extends?(Foobara::BuiltinTypes[:model])
               attributes_type = to_type.target_class.attributes_type

data/projects/command_connectors/src/transformers/load_aggregates_pre_commit_transformer.rb

@@ -1,35 +1,18 @@
+require_relative "load_aggregates_transformer"
+
 module Foobara
   module CommandConnectors
     module Transformers
-      class LoadAggregatesPreCommitTransformer < Value::Transformer
+      class LoadAggregatesPreCommitTransformer < LoadAggregatesTransformer
         def applicable?(request)
           request.command.outcome.success?
         end
 
         def transform(request)
-          load_aggregates(request.command.outcome.result)
+          super(request.command.outcome.result)
 
           request
         end
-
-        def load_aggregates(object)
-          case object
-          when Entity
-            object.class.load_aggregate(object)
-          when Array
-            object.each do |element|
-              load_aggregates(element)
-            end
-          when Hash
-            object.each_key do |key|
-              load_aggregates(key)
-            end
-
-            object.each_value do |value|
-              load_aggregates(value)
-            end
-          end
-        end
       end
     end
   end

data/projects/command_connectors/src/transformers/load_aggregates_transformer.rb

@@ -0,0 +1,30 @@
+module Foobara
+  module CommandConnectors
+    module Transformers
+      class LoadAggregatesTransformer < Value::Transformer
+        def transform(object)
+          load_aggregates(object)
+        end
+
+        def load_aggregates(object)
+          case object
+          when Entity
+            object.class.load_aggregate(object)
+          when Array
+            object.each do |element|
+              load_aggregates(element)
+            end
+          when Hash
+            object.each_key do |key|
+              load_aggregates(key)
+            end
+
+            object.each_value do |value|
+              load_aggregates(value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/command_connectors/src/transformers/load_atoms_pre_commit_transformer.rb

@@ -1,36 +1,18 @@
+require_relative "load_atoms_transformer"
+
 module Foobara
   module CommandConnectors
     module Transformers
-      class LoadAtomsPreCommitTransformer < Value::Transformer
+      class LoadAtomsPreCommitTransformer < LoadAtomsTransformer
         def applicable?(request)
           request.command.outcome.success?
         end
 
         def transform(request)
-          load_atoms(request.command.outcome.result)
+          super(request.command.outcome.result)
 
           request
         end
-
-        def load_atoms(object)
-          case object
-          when Entity
-            if object.persisted? && !object.loaded?
-              object.class.load(object)
-            end
-          when Model
-            load_atoms(object.attributes)
-          when Array
-            object.each do |element|
-              load_atoms(element)
-            end
-          when Hash
-            object.each_pair do |key, value|
-              load_atoms(key)
-              load_atoms(value)
-            end
-          end
-        end
       end
     end
   end

data/projects/command_connectors/src/transformers/load_atoms_transformer.rb

@@ -0,0 +1,31 @@
+module Foobara
+  module CommandConnectors
+    module Transformers
+      class LoadAtomsTransformer < Value::Transformer
+        def transform(object)
+          load_atoms(object)
+        end
+
+        def load_atoms(object)
+          case object
+          when Entity
+            if object.persisted? && !object.loaded?
+              object.class.load(object)
+            end
+          when Model
+            load_atoms(object.attributes)
+          when Array
+            object.each do |element|
+              load_atoms(element)
+            end
+          when Hash
+            object.each_pair do |key, value|
+              load_atoms(key)
+              load_atoms(value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/common/src/error.rb

@@ -231,6 +231,10 @@ module Foobara
       has_build_error = false
 
       1.upto(10) do |i|
+        backtrace_line = backtrace_when_initialized[i]
+
+        break unless backtrace_line
+
         if backtrace_when_initialized[i].end_with?("#build_error'")
           index = i + 1
           has_build_error = true

data/projects/common/src/error_collection.rb

@@ -1,22 +1,15 @@
 module Foobara
-  # TODO: inherit array instead of delegating
-  class ErrorCollection
+  class ErrorCollection < Array
     class ErrorAlreadySetError < StandardError; end
 
     class << self
       def to_h(errors)
         new.tap do |collection|
           collection.add_errors(errors)
-        end.to_h
+        end.errors_hash
       end
     end
 
-    attr_reader :error_array
-
-    def initialize
-      @error_array = []
-    end
-
     def success?
       empty?
     end
@@ -25,14 +18,18 @@ module Foobara
       !empty?
     end
 
-    foobara_delegate :empty?, :partition, :size, :clear, to: :error_array
-
     def errors
-      error_array
+      # :nocov:
+      warn "DEPRECATED: Do not call ErrorCollection#errors instead just use the collection directly."
+      self
+      # :nocov:
     end
 
     def each_error(&)
-      error_array.each(&)
+      # :nocov:
+      warn "DEPRECATED: This method will be deprecated in the coming version"
+      each(&)
+      # :nocov:
     end
 
     def has_error?(error)
@@ -42,15 +39,13 @@ module Foobara
         # :nocov:
       end
 
-      error_array.include?(error)
+      include?(error)
     end
 
     def add_error(error_or_collection_or_error_hash)
       error = case error_or_collection_or_error_hash
               when Error
                 error_or_collection_or_error_hash
-              when ErrorCollection
-                return add_errors(error_or_collection_or_error_hash.errors)
               when Hash
                 if error_or_collection_or_error_hash.key?(:symbol) &&
                    error_or_collection_or_error_hash.key?(:message)
@@ -73,25 +68,32 @@ module Foobara
         raise ErrorAlreadySetError, "cannot set #{error} more than once"
       end
 
-      error_array << error
+      self << error
     end
 
     def add_errors(errors)
       Util.array(errors).each { |error| add_error(error) }
     end
 
-    def to_h
-      error_array.to_h do |error|
-        [error.key, error.to_h]
+    def errors_hash
+      each_with_object({}) do |error, hash|
+        hash[error.key] = error.to_h
       end
     end
 
     def to_sentence
-      Util.to_sentence(error_array.map(&:message))
+      Util.to_sentence(map(&:message))
     end
 
     def keys
-      error_array.map(&:key)
+      map(&:key)
+    end
+
+    def to_h
+      # :nocov:
+      warn "DEPRECATED: Use #errors_hash instead"
+      errors_hash
+      # :nocov:
     end
   end
 end

data/projects/common/src/error_key.rb

@@ -1,5 +1,5 @@
 module Foobara
-  # TODO: path's have use outside of errors. Make this more general.
+  # TODO: paths have use outside of errors. Make this more general.
   class ErrorKey
     # TODO: use this wherever it makes sense
     EMPTY_PATH = [].freeze

data/projects/common/src/outcome.rb

@@ -56,29 +56,35 @@ module Foobara
     end
 
     foobara_delegate :has_errors?,
-                     :errors,
-                     :each_error,
                      :has_error?,
                      :add_error,
                      :add_errors,
                      to: :error_collection
 
+    def errors
+      error_collection
+    end
+
+    def each_error(&)
+      error_collection.each(&)
+    end
+
     def success?
       !has_errors?
     end
 
     def fatal?
-      errors.any?(&:fatal?)
+      error_collection.any?(&:fatal?)
     end
 
     def raise!
       return if success?
 
-      error = errors.first
+      error = error_collection.first
       original_backtrace = error.backtrace_when_initialized
 
-      if errors.size > 1
-        error = UnsuccessfulOutcomeError.new(errors)
+      if error_collection.size > 1
+        error = UnsuccessfulOutcomeError.new(error_collection)
       end
 
       error.set_backtrace(original_backtrace)
@@ -93,7 +99,7 @@ module Foobara
     end
 
     def errors_hash
-      error_collection.to_h
+      error_collection.errors_hash
     end
 
     def errors_sentence

data/projects/detached_entity/lib/foobara/detached_entity.rb

@@ -16,6 +16,7 @@ module Foobara
       end
 
       def reset_all
+        Foobara.raise_if_production!("reset_all")
         install!
       end
     end

data/projects/domain/src/domain_module_extension.rb

@@ -430,7 +430,6 @@ module Foobara
           end
         end
 
-        # TODO: can we kill this skip concept?
         def foobara_manifest
           to_include = TypeDeclarations.foobara_manifest_context_to_include
 

data/projects/domain/src/organization.rb

@@ -4,7 +4,6 @@ module Foobara
     class NoSuchOrganization < StandardError; end
 
     class << self
-      # TODO: move this to organization.rb
       def to_organization(object)
         case object
         when nil

data/projects/entity/lib/foobara/entity.rb

@@ -1,5 +1,5 @@
 module Foobara
-  # TODO: I think we should have a configuration that indicates if created records can have primary keys past to them
+  # TODO: I think we should have a configuration that indicates if created records can have primary keys passed to them
   # or not. That is, do primary keys get issued by the database upon insertion? Or are they generated externally
   # and passed in? Would be nice to have programmatic clarification via explicit configuration.
   class Entity < DetachedEntity
@@ -21,6 +21,7 @@ module Foobara
       end
 
       def reset_all
+        Foobara.raise_if_production!("reset_all")
         Entity::Concerns::Callbacks.reset_all
 
         install!

data/projects/entity/src/association_depth.rb

@@ -0,0 +1,7 @@
+module Foobara
+  module AssociationDepth
+    ATOM = :atom
+    AGGREGATE = :aggregate
+    PRIMARY_KEY_ONLY = :primary_key_only
+  end
+end

data/projects/entity/src/concerns/callbacks.rb

@@ -6,6 +6,7 @@ module Foobara
 
         class << self
           def reset_all
+            Foobara.raise_if_production!("reset_all")
             Entity.instance_variable_set("@class_callback_registry", nil)
           end
         end

data/projects/foobara/src/foobara.rb

@@ -1,6 +1,8 @@
 require_relative "project"
 
 module Foobara
+  class MethodCantBeCalledInProductionError < StandardError; end
+
   class << self
     def require_project_file(project, path)
       require_relative("../../#{project}/src/#{path}")
@@ -47,7 +49,14 @@ module Foobara
     end
 
     def reset_alls
+      raise_if_production!("reset_alls")
       all_projects.each_value(&:reset_all)
     end
+
+    def raise_if_production!(*)
+      if ENV["FOOBARA_ENV"].nil? || ENV["FOOBARA_ENV"] == "production"
+        raise MethodCantBeCalledInProductionError
+      end
+    end
   end
 end

data/projects/foobara/src/project.rb

@@ -34,6 +34,7 @@ module Foobara
     end
 
     def reset_all
+      Foobara.raise_if_production!("reset_all")
       if self.module.respond_to?(:reset_all)
         self.module.reset_all
       end

data/projects/manifest/src/foobara/manifest/possible_error.rb

@@ -19,8 +19,6 @@ module Foobara
         self[:manually_added]
       end
 
-      # TODO: this has to die
-
       # oops, shadowed the convenience method
       def _path
         method_missing(:path)

data/projects/model/lib/foobara/model.rb

@@ -28,6 +28,7 @@ module Foobara
       end
 
       def reset_all
+        Foobara.raise_if_production!("reset_all")
         install!
       end
     end

data/projects/model/src/model.rb

@@ -1,9 +1,6 @@
 require "inheritable_thread_vars"
 
 module Foobara
-  # TODO: either make this an abstract base class of ValueModel and Entity or rename it to ValueModel
-  # and have Entity inherit from it...
-  # TODO: also, why is this at the root level instead of in a project??
   class Model
     class NoSuchAttributeError < StandardError; end
     class AttributeIsImmutableError < StandardError; end
@@ -312,7 +309,7 @@ module Foobara
     end
 
     def validation_errors
-      attributes_type.process_value(attributes).errors
+      attributes_type.process_value(attributes).error_collection
     end
 
     def validate!

data/projects/namespace/src/namespace.rb

@@ -11,7 +11,6 @@ module Foobara
         Thread.current[:foobara_current_namespace] || global
       end
 
-      # TODO: eliminate deprecated_namespace and yield instead
       def use(namespace)
         unless namespace.is_a?(Namespace::IsNamespace)
           # :nocov:

data/projects/namespace/src/namespace_helpers.rb

@@ -248,10 +248,12 @@ module Foobara
             next if parent == mod
 
             if parent && !parent.scoped_full_path.empty?
-              next if _start_with?(parent.scoped_full_path, mod.scoped_full_path)
+              next if Foobara::Util.start_with?(parent.scoped_full_path, mod.scoped_full_path)
             end
 
-            if _start_with?(scoped.scoped_full_path, mod.scoped_full_path)
+            next if scoped.scoped_full_path == mod.scoped_full_path
+
+            if Foobara::Util.start_with?(scoped.scoped_full_path, mod.scoped_full_path)
               scoped.scoped_path = scoped.scoped_full_path[mod.scoped_full_path.size..]
 
               if parent
@@ -268,17 +270,6 @@ module Foobara
             end
           end
         end
-
-        # TODO: move to util
-        def _start_with?(large_array, small_array)
-          return false unless large_array.size > small_array.size
-
-          small_array.each.with_index do |item, index|
-            return false unless large_array[index] == item
-          end
-
-          true
-        end
       end
 
       def foobara_namespace!(scoped_path: nil, ignore_modules: nil)

data/projects/persistence/lib/foobara/persistence.rb

@@ -2,6 +2,7 @@ module Foobara
   module Persistence
     class << self
       def reset_all
+        Foobara.raise_if_production!("reset_all")
         @tables_for_entity_class_name = @bases = @default_crud_driver = @default_base = nil
         EntityBase::Transaction::Concerns::EntityCallbackHandling.reset_all
         EntityBase::Transaction.reset_all

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

@@ -10,6 +10,7 @@ module Foobara
           module EntityCallbackHandling
             class << self
               def reset_all
+                Foobara.raise_if_production!("reset_all")
                 install!
               end
 

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

@@ -21,6 +21,7 @@ module Foobara
               end
 
               def reset_all
+                Foobara.raise_if_production!("reset_all")
                 @open_transactions = nil
               end
 

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

@@ -2,6 +2,7 @@ module Foobara
   module TypeDeclarations
     class << self
       def reset_all
+        Foobara.raise_if_production!("reset_all")
         # 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"

data/projects/type_declarations/src/attributes_transformers/from_yaml.rb

@@ -3,6 +3,12 @@ module Foobara
     class << self
       # TODO: dry this up with a .subclass method in AttributesTransformers?
       def from_yaml(*attribute_names)
+        if attribute_names.empty?
+          # :nocov:
+          raise ArgumentError, "You must specify at least one attribute name"
+          # :nocov:
+        end
+
         symbol = symbol_for_attribute_names(attribute_names)
         existing = FromYaml.foobara_lookup(symbol, mode: Namespace::LookupMode::DIRECT)
 

data/projects/type_declarations/src/attributes_transformers/only.rb

@@ -2,10 +2,18 @@ module Foobara
   class AttributesTransformers < TypeDeclarations::TypedTransformer
     class << self
       def only(*attribute_names)
+        if attribute_names.empty?
+          # :nocov:
+          raise ArgumentError, "You must specify at least one attribute name"
+          # :nocov:
+        end
+
         symbol = symbol_for_attribute_names(attribute_names)
         existing = Only.foobara_lookup(symbol, mode: Namespace::LookupMode::DIRECT)
 
-        return existing if existing
+        if existing
+          return existing
+        end
 
         transformer_class = Class.new(Only)
         transformer_class.only_attributes = attribute_names

data/projects/type_declarations/src/attributes_transformers/reject.rb

@@ -2,6 +2,17 @@ module Foobara
   class AttributesTransformers < TypeDeclarations::TypedTransformer
     class << self
       def reject(*attribute_names)
+        if attribute_names.empty?
+          # :nocov:
+          raise ArgumentError, "You must specify at least one attribute name"
+          # :nocov:
+        end
+
+        symbol = symbol_for_attribute_names(attribute_names)
+        existing = Reject.foobara_lookup(symbol, mode: Namespace::LookupMode::DIRECT)
+
+        return existing if existing
+
         transformer_class = Class.new(Reject)
         transformer_class.reject_attributes = attribute_names
 

data/projects/value/src/processor.rb

@@ -235,7 +235,7 @@ module Foobara
         return old_outcome unless applicable?(value)
 
         process_value(value).tap do |outcome|
-          outcome.add_errors(old_outcome.errors)
+          outcome.add_errors(old_outcome.error_collection)
         end
       end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: foobara
 version: !ruby/object:Gem::Version
-  version: 0.0.135
+  version: 0.0.137
 platform: ruby
 authors:
 - Miles Georgi
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2025-07-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -155,6 +155,7 @@ files:
 - projects/callback/src/registry/chained_conditioned.rb
 - projects/callback/src/registry/chained_multiple_action.rb
 - projects/callback/src/registry/conditioned.rb
+- projects/callback/src/registry/joined_conditioned.rb
 - projects/callback/src/registry/multiple_action.rb
 - projects/callback/src/registry/single_action.rb
 - projects/callback/src/runner.rb
@@ -231,7 +232,9 @@ files:
 - projects/command_connectors/src/transformers/auth_errors_transformer.rb
 - projects/command_connectors/src/transformers/entity_to_primary_key_inputs_transformer.rb
 - projects/command_connectors/src/transformers/load_aggregates_pre_commit_transformer.rb
+- projects/command_connectors/src/transformers/load_aggregates_transformer.rb
 - projects/command_connectors/src/transformers/load_atoms_pre_commit_transformer.rb
+- projects/command_connectors/src/transformers/load_atoms_transformer.rb
 - projects/command_connectors/src/transformers/load_delegated_attributes_entities_pre_commit_transformer.rb
 - projects/common/lib/foobara/common.rb
 - projects/common/src/data_path.rb
@@ -288,6 +291,7 @@ files:
 - projects/domain_mapper/src/domain_mapper.rb
 - projects/domain_mapper/src/domain_mapper_lookups.rb
 - projects/entity/lib/foobara/entity.rb
+- projects/entity/src/association_depth.rb
 - projects/entity/src/concerns/attributes.rb
 - projects/entity/src/concerns/callbacks.rb
 - projects/entity/src/concerns/initialization.rb
@@ -531,7 +535,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.6.2
 specification_version: 4
 summary: A command-centric and discoverable software framework with a focus on domain
   concepts and abstracting away integration code