foobara 0.0.134 → 0.0.136

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7741d716521ec606a818e81e6fdca39b26b4a42d2d2d2de64ecf1078d67a2db2
-  data.tar.gz: b9c1c9e51c08155b848c56eed519302c2722fc84e0baba61d677f21ce3c0f7a9
+  metadata.gz: 6f944c52f318016bd2742fb96208d11a2647d4802ee0a1ac4fbb5b353c5d6ad4
+  data.tar.gz: 5c7560766afe430188cd41053ce9f470eae20605dba8dde824432b760e6aa336
 SHA512:
-  metadata.gz: 732828b89b9a9bfc01226f89f83f1087a010e8f72ee71f5f49a2cd4942f12c22e506d3f228488f408bee41c4f43bb9737e3fb94fd5b39904230271ce8d9ab38c
-  data.tar.gz: 2cdb0f651548752a8ba603a2d6d25caea56deb6c3fc662583a533831bcfe607b9334e438333b590face7b6ee3f3f62d7e633bebb8e7feba25288c5d6b6f8ff60
+  metadata.gz: 3bf5da1d2282282a3d17eb44a0f8ca815c525800f71de56a05ed1c1b66babf5662293a0549df8a2ba6ee88da6cca7fe334f7a852d82b010afcf05f6d21ba1541
+  data.tar.gz: 1444d194eaa3389270cdd23422ec294a59f523e1a71291a92551951987b54c7e316ce724465f7d0fa1151e5c7c2bad84879435eac2908c402f1c3ee888224c5f

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+# [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
+
 # [0.0.134] - 2025-06-27
 
 - Add LoadAtomsPreCommitTransformer

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/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/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

@@ -30,5 +30,5 @@ module Foobara
     end
   end
 
-  Monorepo.project "command_connectors"
+  project "command_connectors"
 end

data/projects/command_connectors/src/command_connector.rb

@@ -303,7 +303,7 @@ module Foobara
     end
 
     def connect_delayed(registerable_name, *args, **opts)
-      delayed_connections[registerable_name] = { args:, opts: }
+      delayed_connections[registerable_name.to_s] = { args:, opts: }
     end
 
     def delayed_connections

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/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_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/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

data/projects/entity/src/association_depth.rb

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

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

@@ -1,43 +1,47 @@
 require "foobara/util"
-require "foobara/monorepo"
+# TODO: Weird to have both of these requiring each other...
+require "foobara"
+
+Foobara::Util.require_directory "#{__dir__}/../../src"
 
 module Foobara
+  # TODO: delete this but deprecate it for now to not break other projects
+  Monorepo = Foobara
+
   module All
     # just makes Rubocop happy
     # TODO: delete this and make Rubocop exception in .rubocop.yml
   end
 
-  module Monorepo
-    # could be independent projects
-    projects "delegate", # Let's just kill delegate
-             "concerns",
-             "weak_object_set",
-             "enumerated",
-             "callback",
-             "state_machine",
-             "namespace"
+  # could be independent projects
+  projects "delegate", # Let's just kill delegate
+           "concerns",
+           "weak_object_set",
+           "enumerated",
+           "callback",
+           "state_machine",
+           "namespace"
 
-    # various components of the foobara framework that have some level of coupling.
-    # for example, Error in common knows about (or could be implemented to know about)
-    # type declarations to expose its context type.
-    projects "domain",
-             "common",
-             "value",
-             "types",
-             "type_declarations",
-             "builtin_types",
-             "model",
-             "detached_entity",
-             "entity",
-             "model_attribute_helpers",
-             "nested_transactionable",
-             "command",
-             "domain_mapper",
-             "persistence", # Feels like this would be loaded before command?
-             "in_memory_crud_driver_minimal",
-             "in_memory_crud_driver",
-             "manifest"
+  # various components of the foobara framework that have some level of coupling.
+  # for example, Error in common knows about (or could be implemented to know about)
+  # type declarations to expose its context type.
+  projects "domain",
+           "common",
+           "value",
+           "types",
+           "type_declarations",
+           "builtin_types",
+           "model",
+           "detached_entity",
+           "entity",
+           "model_attribute_helpers",
+           "nested_transactionable",
+           "command",
+           "domain_mapper",
+           "persistence", # Feels like this would be loaded before command?
+           "in_memory_crud_driver_minimal",
+           "in_memory_crud_driver",
+           "manifest"
 
-    install!
-  end
+  install!
 end

data/projects/foobara/lib/foobara.rb

@@ -1,3 +1,4 @@
+# TODO: weird to have both these files requiring one another
 require "foobara/all"
 
 module Foobara

data/projects/foobara/src/foobara.rb

@@ -0,0 +1,62 @@
+require_relative "project"
+
+module Foobara
+  class MethodCantBeCalledInProductionError < StandardError; end
+
+  class << self
+    def require_project_file(project, path)
+      require_relative("../../#{project}/src/#{path}")
+    end
+
+    attr_accessor :is_installed
+
+    def all_projects
+      @all_projects ||= {}
+    end
+
+    def projects(*symbols)
+      symbols.each do |symbol|
+        project(symbol)
+      end
+    end
+
+    def project(symbol, project_path: nil)
+      if all_projects.key?(symbol)
+        # :nocov:
+        raise ArgumentError, "Project #{symbol} already loaded"
+        # :nocov:
+      end
+
+      project = Project.new(symbol, project_path:)
+      project.load
+
+      all_projects[symbol] = project
+
+      if is_installed
+        project.install!
+
+        all_projects.each_pair do |key, existing_project|
+          next if key == symbol
+
+          existing_project.new_project_added(project)
+        end
+      end
+    end
+
+    def install!
+      self.is_installed = true
+      all_projects.each_value(&:install!)
+    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

@@ -0,0 +1,48 @@
+module Foobara
+  class Project
+    attr_accessor :symbol, :project_path
+
+    def initialize(symbol, project_path: nil)
+      self.symbol = symbol
+      self.project_path = project_path || "#{__dir__}/../../#{symbol}"
+    end
+
+    def require_path
+      "foobara/#{symbol}"
+    end
+
+    def module_name
+      Util.classify(symbol)
+    end
+
+    def module
+      Foobara.const_get(module_name)
+    end
+
+    def load
+      require require_path
+      src_dir = "#{project_path}/src"
+      if Dir.exist?(src_dir)
+        Util.require_directory(src_dir)
+      end
+    end
+
+    def install!
+      if self.module.respond_to?(:install!)
+        self.module.install!
+      end
+    end
+
+    def reset_all
+      if self.module.respond_to?(:reset_all)
+        self.module.reset_all
+      end
+    end
+
+    def new_project_added(project)
+      if self.module.respond_to?(:new_project_added)
+        self.module.new_project_added(project)
+      end
+    end
+  end
+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/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

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:

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foobara
 version: !ruby/object:Gem::Version
-  version: 0.0.134
+  version: 0.0.136
 platform: ruby
 authors:
 - Miles Georgi
@@ -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
@@ -320,6 +324,8 @@ files:
 - projects/enumerated/src/values.rb
 - projects/foobara/lib/foobara.rb
 - projects/foobara/lib/foobara/all.rb
+- projects/foobara/src/foobara.rb
+- projects/foobara/src/project.rb
 - projects/in_memory_crud_driver/lib/foobara/in_memory_crud_driver.rb
 - projects/in_memory_crud_driver/src/in_memory.rb
 - projects/in_memory_crud_driver_minimal/lib/foobara/in_memory_crud_driver_minimal.rb
@@ -374,8 +380,6 @@ files:
 - projects/model_attribute_helpers/lib/foobara/model_attribute_helpers.rb
 - projects/model_attribute_helpers/src/attribute_helper_aliases.rb
 - projects/model_attribute_helpers/src/attribute_helpers.rb
-- projects/monorepo/lib/foobara/monorepo.rb
-- projects/monorepo/lib/foobara/monorepo/project.rb
 - projects/namespace/lib/foobara/namespace.rb
 - projects/namespace/src/ambiguous_registry.rb
 - projects/namespace/src/base_registry.rb
@@ -512,7 +516,6 @@ require_paths:
 - "./projects/manifest/lib"
 - "./projects/model/lib"
 - "./projects/model_attribute_helpers/lib"
-- "./projects/monorepo/lib"
 - "./projects/namespace/lib"
 - "./projects/nested_transactionable/lib"
 - "./projects/persistence/lib"

data/projects/monorepo/lib/foobara/monorepo/project.rb

@@ -1,54 +0,0 @@
-module Foobara
-  module Monorepo
-    # TODO: make this MonorepoProject and have a more generic Project so that other projects outside of the
-    # repo can have things like reset_all called on th.
-    class Project
-      attr_accessor :symbol, :project_path
-
-      # TODO: we should move these concepts out of "Monorepo" and maybe into Foobara because we sometimes need to
-      # be able to install!/reset foobara code that's been extracted into a gem
-      def initialize(symbol, project_path: nil)
-        self.symbol = symbol
-        self.project_path = project_path || "#{__dir__}/../../../../../projects/#{symbol}"
-      end
-
-      def require_path
-        "foobara/#{symbol}"
-      end
-
-      def module_name
-        Util.classify(symbol)
-      end
-
-      def module
-        Foobara.const_get(module_name)
-      end
-
-      def load
-        require require_path
-        src_dir = "#{project_path}/src"
-        if Dir.exist?(src_dir)
-          Util.require_directory(src_dir)
-        end
-      end
-
-      def install!
-        if self.module.respond_to?(:install!)
-          self.module.install!
-        end
-      end
-
-      def reset_all
-        if self.module.respond_to?(:reset_all)
-          self.module.reset_all
-        end
-      end
-
-      def new_project_added(project)
-        if self.module.respond_to?(:new_project_added)
-          self.module.new_project_added(project)
-        end
-      end
-    end
-  end
-end

data/projects/monorepo/lib/foobara/monorepo.rb

@@ -1,63 +0,0 @@
-require_relative "monorepo/project"
-
-module Foobara
-  class << self
-    def require_project_file(project, path)
-      require_relative("../../../#{project}/src/#{path}")
-    end
-
-    def reset_alls
-      Monorepo.reset_alls
-    end
-  end
-
-  # TODO: We should rename this to Projects or something else because we need to manage this stuff for projects
-  # inside and outside of the monorepo.
-  module Monorepo
-    class << self
-      attr_accessor :is_installed
-
-      def all_projects
-        @all_projects ||= {}
-      end
-
-      def projects(*symbols)
-        symbols.each do |symbol|
-          project(symbol)
-        end
-      end
-
-      def project(symbol, project_path: nil)
-        if all_projects.key?(symbol)
-          # :nocov:
-          raise ArgumentError, "Project #{symbol} already loaded"
-          # :nocov:
-        end
-
-        project = Project.new(symbol, project_path:)
-        project.load
-
-        all_projects[symbol] = project
-
-        if is_installed
-          project.install!
-
-          all_projects.each_pair do |key, existing_project|
-            next if key == symbol
-
-            existing_project.new_project_added(project)
-          end
-        end
-      end
-
-      def install!
-        self.is_installed = true
-        all_projects.each_value(&:install!)
-      end
-
-      def reset_alls
-        all_projects.each_value(&:reset_all)
-      end
-    end
-  end
-end