foobara 0.6.5 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f7628f3975299e2c2d578d47b6ea01cf00d10d0c64566b01d307ae44d400cd6
-  data.tar.gz: 7e1964b48bea37ba9206c85d171c0c52985e9499131a3e96bcf661559730b4da
+  metadata.gz: 64b471d0d0bf93acf6326e484b67d1be35f7c0c883bc315738f680e4c8119613
+  data.tar.gz: 9477f64763952ea8d819576545d6f9d06d7bb1ad562ea6dca83532297331859a
 SHA512:
-  metadata.gz: 8061eb55fbc5879d63532708009f9591f4c5c9766a6a282612b51fa8c48a80e537ad5f4e488150f57434cf50a621d4a0c687efcc0963508808470e00c5c0b76b
-  data.tar.gz: f593b3dcc25323a6253c928ed4d4735386e65c0cebf4e4ef6d219d8ac8dccfa253b1223aa85d227c66ffdf2c409a39d0ea8632ac90cc489ff8b529b9f41f8913
+  metadata.gz: 941279f67447a52f9632f620637f011f21bae87766b4a8040846744751e17ba779a21db495cd0ef010152f908af015f8aad87246ab0215a9cd684673bb2c8793
+  data.tar.gz: de42b7abaff5512bdc00eba73d862778866034dd1a5d9b354649648a27b2ba2208062550e99ae4c91df8f51456f96bad4f7b4b89d2e263e13cc87c6d1daed231

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+# [0.7.1] - 2026-10-09
+
+- Fix bug that removes Foobara::RuntimeError from GlobalDomain during type declaration init
+
+# [0.7.0] - 2026-10-09
+
+- Do not allow anything but domains (and orgs as a hack) to be children of orgs
+- Eliminate NoContextTypeSetError and add default context type of {}
+
 # [0.6.5] - 2026-10-04
 
 - Fix a problem where some nested sugary types don't expand correctly when using attributes dsl

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

@@ -57,6 +57,8 @@ module Foobara
             if result_type
               result result_type.reference_or_declaration_data
             end
+
+            # TODO: We don't have to clear out possible error types??
           end
         end
       end

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

@@ -11,6 +11,8 @@ module Foobara
                     :result_transformers,
                     :errors_transformers,
                     :pre_commit_transformers,
+                    # Should we have separate success and error serializers so that serializers can be
+                    # more reusable?
                     :serializers,
                     :request_mutators,
                     :response_mutators,

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

@@ -5,6 +5,7 @@ module Foobara
     module Serializers
       class SuccessSerializer < Serializer
         def always_applicable?
+          # Why is the serializer coupled to a request???
           request.outcome&.success?
         end
       end

data/projects/entities_plumbing/src/serializers/aggregate_serializer.rb

@@ -1,6 +1,10 @@
 module Foobara
   module CommandConnectors
     module Serializers
+      # TODO: put an entity-free version of this in model_plumbing!
+      # TODO: can't this just inherit from Serializer??
+      # TODO: shouldn't this be a transformer? It's not really serializing anything
+      #       just preparing the data for serialization.
       class AggregateSerializer < SuccessSerializer
         def serialize(object)
           case object

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

@@ -62,6 +62,11 @@ module Foobara
         associative_array = build_and_register!(:associative_array, duckture, ::Hash)
         # TODO: uh oh... we do some translations in the casting here...
         build_and_register!(:attributes, associative_array, nil)
+
+        if needs_to_handle_reregistered_types
+          GlobalDomain.foobara_each_command(&:handle_reregistered_types!)
+          self.needs_to_handle_reregistered_types = false
+        end
       end
 
       def reset_all

data/projects/typesystem/projects/builtin_types/src/builtin_types.rb

@@ -5,6 +5,8 @@ module Foobara
 
   module BuiltinTypes
     class << self
+      attr_accessor :needs_to_handle_reregistered_types
+
       # TODO: break this up
       # TODO: much of this behavior is helpful to non-builtin types as well.
       def build_and_register!(
@@ -86,7 +88,17 @@ module Foobara
 
         # TODO: really need to encapsulate this somehow...
         type.type_symbol = type_symbol
-        (type.foobara_parent_namespace || GlobalDomain).foobara_register(type)
+
+        domain = type.foobara_parent_namespace || GlobalDomain
+        mode = Namespace::LookupMode::DIRECT
+
+        exists = domain.foobara_registered?(type_symbol, mode:)
+        if exists
+          domain.foobara_unregister(domain.foobara_lookup_type(type_symbol, mode:))
+          self.needs_to_handle_reregistered_types = true
+        end
+
+        domain.foobara_register(type)
 
         supported_casters_module = Util.constant_value(builtin_type_module, :SupportedCasters)
         supported_caster_classes = if supported_casters_module

data/projects/typesystem/projects/domain/src/domain_module_extension.rb

@@ -234,12 +234,23 @@ module Foobara
             domain.foobara_manifest_reference
           end.sort
 
-          types = foobara_all_type(mode: Namespace::LookupMode::DIRECT).map do |type|
-            if to_include
-              to_include << type
+          types = []
+
+          # Using this to support deprecated Foobara.manifest without risking
+          # breakage elsewhere
+          if TypeDeclarations.foobara_manifest_context_include_unreachable?
+            foobara_all(mode: Namespace::LookupMode::DIRECT).each do |scoped|
+              to_include << scoped if to_include
+              types << scoped.foobara_manifest_reference if scoped.scoped_category == :type
             end
-            type.foobara_manifest_reference
-          end.sort
+          else
+            foobara_all_type(mode: Namespace::LookupMode::DIRECT).each do |scoped|
+              to_include << scoped if to_include
+              types << scoped.foobara_manifest_reference
+            end
+          end
+
+          types.sort!
 
           manifest = super.merge(types:)
 

data/projects/typesystem/projects/domain/src/extensions/foobara.rb

@@ -11,7 +11,7 @@ module Foobara
     private def debug_manifest
       to_include = Namespace.global.foobara_all_organization.to_set
 
-      TypeDeclarations.with_manifest_context(to_include:) do
+      TypeDeclarations.with_manifest_context(to_include:, include_unreachable: true) do
         included = {}
 
         h = {}

data/projects/typesystem/projects/domain/src/module_extension.rb

@@ -17,6 +17,8 @@ module Foobara
           # simplecov:enable
         end
 
+        include DomainModuleExtension
+
         unless is_a?(Namespace::IsNamespace)
           foobara_namespace!
           foobara_autoset_namespace!(default_namespace: Foobara::GlobalOrganization)
@@ -24,8 +26,6 @@ module Foobara
 
           foobara_parent_namespace.foobara_register(self)
         end
-
-        include(DomainModuleExtension)
       end
 
       def foobara_organization!

data/projects/typesystem/projects/namespace/src/namespace_helpers.rb

@@ -155,11 +155,15 @@ module Foobara
 
           while parent_mod
             if parent_mod.is_a?(Foobara::Namespace::IsNamespace)
-              mod.scoped_namespace = parent_mod
-              return
-            else
-              parent_mod = Util.module_for(parent_mod)
+              # Only domains can have an org as its parent
+              # Important that Foobara::GlobalOrganization's parent is Foobara or it breaks categories
+              if mod.foobara_organization? || mod.foobara_domain? || !parent_mod.foobara_organization?
+                mod.scoped_namespace = parent_mod
+                return
+              end
             end
+
+            parent_mod = Util.module_for(parent_mod)
           end
 
           mod.scoped_namespace = default_namespace if default_namespace
@@ -216,6 +220,13 @@ module Foobara
             adjusted_scoped_path << path_part unless mod.scoped_namespace&.scoped_ignore_module?(next_mod)
           end
 
+          if parent&.foobara_organization?
+            if !mod.foobara_domain? && !mod.foobara_organization?
+              parent = Foobara::GlobalDomain
+              adjusted_scoped_path = mod_name.split("::")
+            end
+          end
+
           mod.scoped_path_autoset = true
           mod.scoped_path = adjusted_scoped_path
 

data/projects/typesystem/projects/namespace/src/scoped.rb

@@ -7,7 +7,6 @@ module Foobara
 
     def scoped_path
       if scoped_unregistered?
-        # TODO: can probably delete this defensive check
         # simplecov:disable
         raise "Cannot use unregistered Scoped object"
         # simplecov:enable

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

@@ -17,35 +17,56 @@ module Foobara
         [
           :@foobara_children,
           :@foobara_registry,
-          :@foobara_type_builder
+          :@foobara_type_builder,
+          :@lru_cache
         ].each do |var_name|
-          # Don't we only have to do this for Foobara and not all of these??
-          [
-            Namespace.global,
-            Foobara::GlobalOrganization,
-            Foobara::GlobalDomain,
-            Domain,
-            Types::Type,
-            Value::Processor,
-            Error
-          ].each do |klass|
+          namespaces_to_reset.each do |klass|
             if klass.instance_variable_defined?(var_name)
               klass.remove_instance_variable(var_name)
             end
           end
         end
 
-        @original_scoped.each do |scoped|
-          Namespace.global.foobara_register(scoped)
-        end
+        Namespace.clear_lru_cache!
+
+        @original_scoped.each_key do |namespace|
+          scoped = @original_scoped[namespace]
+          to_remove = []
+
+          scoped.each do |child|
+            if child.scoped_unregistered?
+              to_remove << child
+              next
+            end
+
+            unless namespace.foobara_registered?(child, mode: Namespace::LookupMode::DIRECT)
+              namespace.foobara_register(child)
+            end
+          end
 
-        children = Namespace.global.foobara_children
+          children = namespace.foobara_children
+
+          to_remove.each do |child|
+            children.delete(child)
+            scoped.delete(child)
+          end
+
+          to_remove.clear
+
+          @original_children[namespace].each do |child|
+            if child.scoped_unregistered?
+              to_remove << child
+              next
+            end
+            children << child unless children.include?(child)
+          end
 
-        @original_children.each do |child|
-          children.foobara_children << child unless children.include?(child)
+          to_remove.each do |child|
+            @original_children[namespace].delete(child)
+          end
         end
 
-        GlobalOrganization.foobara_register(GlobalDomain)
+        Namespace.clear_lru_cache!
 
         register_type_declaration(Handlers::RegisteredTypeDeclaration.new)
         register_type_declaration(Handlers::ExtendRegisteredTypeDeclaration.new)
@@ -101,11 +122,15 @@ module Foobara
           }
         end
 
-        Value::DataError.singleton_class.define_method :context_type_declaration do
-          {
-            attribute_name: :symbol,
-            value: :duck
-          }
+        ::Foobara::Value::DataError.instance_exec do
+          class << self
+            def context_type_declaration
+              {
+                attribute_name: :symbol,
+                value: :duck
+              }.freeze
+            end
+          end
         end
       end
 
@@ -113,11 +138,33 @@ module Foobara
         capture_current_namespaces
       end
 
+      private
+
       def capture_current_namespaces
         # TODO: this feels like the wrong place to do this but doing it here for now to make sure it's done when
         # most important
-        @original_scoped = Namespace.global.foobara_registry.all_scoped.dup
-        @original_children = Namespace.global.foobara_children.dup
+        @original_scoped = {}
+        @original_children = {}
+
+        namespaces_to_reset.each do |namespace|
+          next unless namespace.is_a?(Namespace::IsNamespace)
+
+          @original_scoped[namespace] = namespace.foobara_registry.all_scoped.dup
+          @original_children[namespace] = namespace.foobara_children.dup
+        end
+      end
+
+      def namespaces_to_reset
+        [
+          Foobara::GlobalDomain,
+          Foobara::GlobalOrganization,
+          Value::Processor,
+          Types::Type,
+          Domain,
+          Error,
+          Foobara,
+          Namespace.global
+        ]
       end
     end
   end

data/projects/typesystem/projects/type_declarations/src/error_extension.rb

@@ -22,36 +22,20 @@ module Foobara
     self.validate_error_context_enabled = true
 
     module ErrorExtension
-      class NoContextTypeSetError < StandardError
-        def initialize
-          super("No context type declaration set. Either set it or mark the error as abstract")
-        end
-      end
-
       include Concern
       # TODO: replace this with some kind of Foobara::TypeBuilder version
       include WithRegistries
 
       module ClassMethods
         def context_type
-          @context_type ||= begin
-            Foobara::Domain.foobara_type_from_declaration(self, context_type_declaration)
-          rescue NoContextTypeSetError
-            if abstract?
-              nil
-            else
-              # simplecov:disable
-              raise
-              # simplecov:enable
-            end
-          end
-        end
+          return @context_type if defined?(@context_type)
 
-        def context_type_declaration
-          # simplecov:disable
-          raise NoContextTypeSetError
-          # simplecov:enable
+          @context_type = unless abstract?
+                            Foobara::Domain.foobara_type_from_declaration(self, context_type_declaration)
+                          end
         end
+
+        def context_type_declaration = {}.freeze
       end
 
       def initialize(...)

data/projects/typesystem/projects/type_declarations/src/type_declarations.rb

@@ -82,7 +82,6 @@ module Foobara
         using_mode(Mode::STRINGIFIED, &)
       end
 
-      # TODO: use manifest context instead
       def using_mode(new_mode, &)
         with_manifest_context(mode: new_mode, &)
       end
@@ -116,8 +115,17 @@ module Foobara
         Thread.inheritable_thread_local_var_get("foobara_manifest_context")
       end
 
-      allowed_context_keys = [:detached, :to_include, :mode, :remove_sensitive, :include_processors]
-      booleans = [:detached, :remove_sensitive, :include_processors]
+      allowed_context_keys = [
+        :detached,
+        :to_include,
+        :mode,
+        :remove_sensitive,
+        :include_processors,
+        # This is just a flag to allow the deprecated Foobara.manifest to include
+        # everything without risk of breaking something in command connector manifests
+        :include_unreachable
+      ]
+      booleans = [:detached, :remove_sensitive, :include_processors, :include_unreachable]
 
       booleans.each do |context_item|
         define_method "foobara_manifest_context_#{context_item}?" do

data/projects/typesystem/projects/types/src/extensions/error.rb

@@ -5,22 +5,11 @@ module Foobara
         if args.size == 1
           context_type.types_depended_on(args[0])
         elsif args.empty?
-          begin
-            if context_type
-              context_type.types_depended_on
-            else
-              raise Foobara::TypeDeclarations::ErrorExtension::NoContextTypeSetError
-            end
-          rescue Foobara::TypeDeclarations::ErrorExtension::NoContextTypeSetError
-            if abstract?
-              []
-            else
-              # simplecov:disable
-              raise
-              # simplecov:enable
-            end
+          if abstract?
+            []
+          else
+            context_type.types_depended_on
           end
-
         else
           # simplecov:disable
           raise ArgumentError, "Too many arguments #{args}"

data/version.rb

@@ -1,6 +1,6 @@
 module Foobara
   module Version
-    VERSION = "0.6.5".freeze
+    VERSION = "0.7.1".freeze
     MINIMUM_RUBY_VERSION = [">= 3.4.0", "< 4.1"].freeze
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foobara
 version: !ruby/object:Gem::Version
-  version: 0.6.5
+  version: 0.7.1
 platform: ruby
 authors:
 - Miles Georgi