foobara 0.1.9 → 0.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f058e7ba0dd38cc79d4fa591be119decc9fa12e8d2e9b94de732d01636072b7
-  data.tar.gz: 71b3f8faf719fb02fc21a56a1feec8b506de34cc022244166158ed4b8482842c
+  metadata.gz: e3d84d4d11b964a30291cd92382117fa45a7736e0ee0b6a247224427a33e6598
+  data.tar.gz: d1a2b86a1983b354412c1e83e2dbfc2ad259feddba8d09a01d3ef39038a27163
 SHA512:
-  metadata.gz: 8a928e7ff495266da1595fd702fe2f1d790de3e2fb21df0f4c0ea410a53766c00e724a7ea7c2da31d4be7d77dc9068d78ff77cee95a6945e03a0a81664b12d5c
-  data.tar.gz: 8e70ae9f7fb74d23ab80e99854b318246c61a104ca86c4ef7a031437aa9878dd9213eb7bd952576bb111e7bdf84171f7e2141b959eb604c7bf81e733954ea329
+  metadata.gz: c0c8ed8a92fbc3c1e37172881f855aa0072ffb50cd5f3c652677ddaee2af021aa937a60c2aa35d5c61f110c5b2968474b3cfaf72c593d3f9c5a405f1a3ace968
+  data.tar.gz: e772dc00b34a3293111f49f958c7615507c206c47f10932c461852d0b4a1ada737a9c0c5f198da11bded280aa69d1f0f383e408b241977ec3521fa5e98e76796

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+# [0.1.11] - 2025-09-24
+
+- Make sure type builder caches are cleared when namespace caches are cleared
+- Make sure element type resolution is performed in the right namespace
+- Do not dual-purpose memoized @element_type(s) var, and memoize in IsNamespace.lru_cache instead
+
+# [0.1.10] - 2025-09-11
+
+- Add NotFoundError when an entity input doesn't exist
+- Make #add_input_error more flexible
+- Fix an error path array bug
+- Fix a bug that might prevent inherited possible errors
+
 # [0.1.9] - 2025-09-08
 
 - Support passing load_paths: to Entity.load to pre-load certain associations

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

@@ -78,7 +78,7 @@ module Foobara
                   elsif args.empty? || (args.size == 1 && args.first.is_a?(Hash))
                     error_args = opts.merge(args.first || {})
                     symbol = error_args[:symbol]
-                    path = Util.array(error_args[:input] || error_args[:path])
+                    path = error_args[:input] || error_args[:path]
 
                     error_args = error_args.except(:input)
 
@@ -100,8 +100,14 @@ module Foobara
                     input, symbol, message = args
                     context = opts
 
-                    error_class = self.class.lookup_input_error_class(symbol, input)
-                    error_class.new(path: Util.array(input), symbol:, context:, message:)
+                    if symbol.is_a?(::Class) && symbol < Foobara::Error
+                      error_class = symbol
+                      symbol = error_class.symbol
+                    else
+                      error_class = self.class.lookup_input_error_class(symbol, input)
+                    end
+
+                    error_class.new(path: input, symbol:, context:, message:)
                   else
                     # :nocov:
                     raise ArgumentError,

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

@@ -81,6 +81,11 @@ module Foobara
             symbol = error_class.symbol
 
             possible_error = PossibleError.new(error_class, symbol:, data:)
+
+            if path.is_a?(::String) || path.is_a?(::Symbol)
+              path = path.to_s.split(".")
+            end
+
             possible_error.prepend_path!(path)
 
             possible_error.manually_added = true
@@ -93,10 +98,24 @@ module Foobara
 
           # TODO: kill this method in favor of possible_errors
           def error_context_type_map
+            return @error_context_type_map if defined?(@error_context_type_map)
+
             process_error_constants
-            @error_context_type_map ||= if superclass < Foobara::Command
-                                          superclass.error_context_type_map.dup
-                                        end || {}
+            map = if superclass < Foobara::Command
+                    superclass.error_context_type_map.dup
+                  end || {}
+
+            @error_context_type_map = if @error_context_type_map
+                                        map.merge(@error_context_type_map)
+                                      else
+                                        map
+                                      end
+
+            inputs_association_paths&.each do |data_path|
+              possible_input_error(data_path.to_sym, CommandPatternImplementation::NotFoundError)
+            end
+
+            @error_context_type_map
           end
 
           def register_possible_error_class(possible_error)

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

@@ -6,6 +6,26 @@ module Foobara
 
         include Concern
 
+        module ClassMethods
+          def inputs_association_paths
+            return @inputs_association_paths if defined?(@inputs_association_paths)
+
+            @inputs_association_paths = if inputs_type.nil?
+                                          nil
+                                        else
+                                          keys = Entity.construct_associations(inputs_type).keys
+
+                                          if keys.empty?
+                                            nil
+                                          else
+                                            keys.map do |key|
+                                              DataPath.new(key)
+                                            end
+                                          end
+                                        end
+          end
+        end
+
         attr_reader :inputs, :raw_inputs
 
         def initialize(inputs = {})

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

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

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

@@ -7,6 +7,13 @@ module Foobara
         class CannotHaltWithoutAddingErrors < StandardError; end
         class Halt < StandardError; end
 
+        class NotFoundError < Foobara::DataError
+          context do
+            entity_class :string, :required
+            criteria :duck
+          end
+        end
+
         module ClassMethods
           def run(...)
             new(...).run
@@ -81,7 +88,41 @@ module Foobara
         end
 
         def validate_records
-          # noop
+          self.class.inputs_association_paths&.each do |data_path|
+            if data_path.last == :"#"
+              records = data_path.values_at(@inputs)
+
+              records.each.with_index do |record, index|
+                if record&.persisted? && !record.loaded?
+                  begin
+                    record.class.load(record)
+                  rescue Foobara::Entity::NotFoundError => e
+                    add_input_error(
+                      [*data_path.path[..-2], index],
+                      CommandPatternImplementation::NotFoundError,
+                      criteria: e.criteria,
+                      entity_class: record.class.model_type.scoped_full_name
+                    )
+                  end
+                end
+              end
+            else
+              record = data_path.value_at(@inputs)
+
+              if record&.persisted? && !record.loaded?
+                begin
+                  record.class.load(record)
+                rescue Foobara::Entity::NotFoundError => e
+                  add_input_error(
+                    data_path.to_s,
+                    CommandPatternImplementation::NotFoundError,
+                    criteria: e.criteria,
+                    entity_class: record.class.model_type.scoped_full_name
+                  )
+                end
+              end
+            end
+          end
         end
 
         def validate

data/projects/common/src/error.rb

@@ -215,6 +215,11 @@ module Foobara
       self.message = message
       self.context = context
       self.category = category
+
+      if path.is_a?(::String) || path.is_a?(::Symbol)
+        path = path.to_s.split(".").map(&:to_sym)
+      end
+
       self.path = path
       self.runtime_path = runtime_path
       self.is_fatal = is_fatal

data/projects/domain/src/domain_module_extension.rb

@@ -65,8 +65,6 @@ module Foobara
         def foobara_unregister(scoped)
           scoped = to_scoped(scoped)
 
-          foobara_type_builder.clear_cache
-
           if scoped.is_a?(Foobara::Types::Type)
             parent_mod = nil
 

data/projects/model/src/extensions/type_declarations/handlers/extend_model_type_declaration/to_type_transformer.rb

@@ -77,7 +77,7 @@ module Foobara
               if outcome.success?
                 type = outcome.result
 
-                type.element_types = :Model
+                type.element_types_loader = LazyElementTypes::Model
 
                 model_class = type.target_class
                 existing_model_type = model_class.model_type

data/projects/model/src/extensions/type_declarations/lazy_element_types/model.rb

@@ -5,11 +5,13 @@ module Foobara
         module_function
 
         def resolve(type)
-          attributes_type_declaration = type.declaration_data[:attributes_declaration]
+          Namespace.use type.created_in_namespace do
+            attributes_type_declaration = type.declaration_data[:attributes_declaration]
 
-          type.element_types = TypeDeclarations.strict do
-            handler = Domain.current.foobara_type_builder.handler_for_class(Handlers::ExtendAttributesTypeDeclaration)
-            handler.process_value!(TypeDeclaration.new(attributes_type_declaration))
+            type.element_types = TypeDeclarations.strict do
+              handler = Domain.current.foobara_type_builder.handler_for_class(Handlers::ExtendAttributesTypeDeclaration)
+              handler.process_value!(TypeDeclaration.new(attributes_type_declaration))
+            end
           end
         end
       end

data/projects/namespace/src/is_namespace.rb

@@ -5,11 +5,13 @@ module Foobara
     module IsNamespace
       class << self
         def lru_cache
-          @lru_cache ||= Foobara::LruCache.new(100)
+          @lru_cache ||= Foobara::LruCache.new(200)
         end
 
         def clear_lru_cache!
-          @lru_cache = nil
+          if @lru_cache
+            lru_cache.reset!
+          end
         end
       end
 
@@ -141,7 +143,7 @@ module Foobara
         LookupMode.validate!(mode)
         path = Namespace.to_registry_path(path)
 
-        lru_cache.cached([path, mode, self, filter]) do
+        lru_cache.cached([self, path, mode, *filter]) do
           visited = Set.new
           foobara_lookup_without_cache(path, filter:, mode:, visited:)
         end

data/projects/namespace/src/namespace/lookup_mode.rb

@@ -27,6 +27,7 @@ module Foobara
     #   parent: n
     #   dependent: n
     # TODO: don't we have an enumerated class/project for this?
+    # Maybe use bitmasks for the above 3 places to look instead of a list of 7 lookup types? (There should be 8...)
     module LookupMode
       GENERAL = :general
       RELAXED = :relaxed

data/projects/type_declarations/src/handlers/extend_array_type_declaration/to_type_transformer.rb

@@ -8,7 +8,7 @@ module Foobara
         class ToTypeTransformer < ExtendAssociativeArrayTypeDeclaration::ToTypeTransformer
           def transform(strict_type_declaration)
             type = super
-            type.element_type = :Array
+            type.element_type_loader = LazyElementTypes::Array
             type
           end
         end

data/projects/type_declarations/src/handlers/extend_associative_array_type_declaration/to_type_transformer.rb

@@ -10,7 +10,7 @@ module Foobara
         class ToTypeTransformer < ExtendRegisteredTypeDeclaration::ToTypeTransformer
           def transform(strict_type_declaration)
             type = super
-            type.element_types = :Hash
+            type.element_types_loader = LazyElementTypes::Hash
             type
           end
         end

data/projects/type_declarations/src/handlers/extend_attributes_type_declaration/to_type_transformer.rb

@@ -8,7 +8,7 @@ module Foobara
         class ToTypeTransformer < ExtendAssociativeArrayTypeDeclaration::ToTypeTransformer
           def transform(strict_type_declaration)
             type = super
-            type.element_types = :Attributes
+            type.element_types_loader = LazyElementTypes::Attributes
             type
           end
         end

data/projects/type_declarations/src/handlers/extend_tuple_type_declaration/to_type_transformer.rb

@@ -8,7 +8,7 @@ module Foobara
         class ToTypeTransformer < ExtendAssociativeArrayTypeDeclaration::ToTypeTransformer
           def transform(strict_type_declaration)
             type = super
-            type.element_types = :Tuple
+            type.element_types_loader = LazyElementTypes::Tuple
             type
           end
         end

data/projects/type_declarations/src/lazy_element_types/array.rb

@@ -5,13 +5,15 @@ module Foobara
         module_function
 
         def resolve(type)
-          element_type_declaration = type.declaration_data[:element_type_declaration]
+          Namespace.use type.created_in_namespace do
+            element_type_declaration = type.declaration_data[:element_type_declaration]
 
-          type.element_type = if element_type_declaration
-                                TypeDeclarations.strict do
-                                  Domain.current.foobara_type_from_declaration(element_type_declaration)
+            type.element_type = if element_type_declaration
+                                  TypeDeclarations.strict do
+                                    Domain.current.foobara_type_from_declaration(element_type_declaration)
+                                  end
                                 end
-                              end
+          end
         end
       end
     end

data/projects/type_declarations/src/lazy_element_types/attributes.rb

@@ -5,21 +5,23 @@ module Foobara
         module_function
 
         def resolve(type)
-          type_declarations = type.declaration_data[:element_type_declarations]
+          Namespace.use type.created_in_namespace do
+            type_declarations = type.declaration_data[:element_type_declarations]
 
-          type.element_types = if type_declarations
-                                 if type_declarations.empty?
-                                   {}
-                                 else
-                                   TypeDeclarations.strict do
-                                     domain = Domain.current
+            type.element_types = if type_declarations
+                                   if type_declarations.empty?
+                                     {}
+                                   else
+                                     TypeDeclarations.strict do
+                                       domain = Domain.current
 
-                                     type_declarations.transform_values do |attribute_declaration|
-                                       domain.foobara_type_from_declaration(attribute_declaration)
+                                       type_declarations.transform_values do |attribute_declaration|
+                                         domain.foobara_type_from_declaration(attribute_declaration)
+                                       end
                                      end
                                    end
                                  end
-                               end
+          end
         end
       end
     end

data/projects/type_declarations/src/lazy_element_types/hash.rb

@@ -7,30 +7,32 @@ module Foobara
         module_function
 
         def resolve(type)
-          declaration_data = type.declaration_data
+          Namespace.use type.created_in_namespace do
+            declaration_data = type.declaration_data
 
-          key_type_declaration = declaration_data[:key_type_declaration]
-          value_type_declaration = declaration_data[:value_type_declaration]
+            key_type_declaration = declaration_data[:key_type_declaration]
+            value_type_declaration = declaration_data[:value_type_declaration]
 
-          type.element_types = if key_type_declaration || value_type_declaration
-                                 TypeDeclarations.strict do
-                                   domain = Domain.current
+            type.element_types = if key_type_declaration || value_type_declaration
+                                   TypeDeclarations.strict do
+                                     domain = Domain.current
 
-                                   key_declaration = if key_type_declaration
-                                                       domain.foobara_type_from_declaration(key_type_declaration)
-                                                     else
-                                                       BuiltinTypes[:duck]
-                                                     end
-
-                                   value_declaration = if value_type_declaration
-                                                         domain.foobara_type_from_declaration(value_type_declaration)
+                                     key_declaration = if key_type_declaration
+                                                         domain.foobara_type_from_declaration(key_type_declaration)
                                                        else
                                                          BuiltinTypes[:duck]
                                                        end
 
-                                   [key_declaration, value_declaration]
+                                     value_declaration = if value_type_declaration
+                                                           domain.foobara_type_from_declaration(value_type_declaration)
+                                                         else
+                                                           BuiltinTypes[:duck]
+                                                         end
+
+                                     [key_declaration, value_declaration]
+                                   end
                                  end
-                               end
+          end
         end
       end
     end

data/projects/type_declarations/src/lazy_element_types/tuple.rb

@@ -5,17 +5,19 @@ module Foobara
         module_function
 
         def resolve(type)
-          element_type_declarations = type.declaration_data[:element_type_declarations]
+          Namespace.use type.created_in_namespace do
+            element_type_declarations = type.declaration_data[:element_type_declarations]
 
-          type.element_types = if element_type_declarations
-                                 TypeDeclarations.strict do
-                                   domain = Domain.current
+            type.element_types = if element_type_declarations
+                                   TypeDeclarations.strict do
+                                     domain = Domain.current
 
-                                   element_type_declarations.map do |element_type_declaration|
-                                     domain.foobara_type_from_declaration(element_type_declaration)
+                                     element_type_declarations.map do |element_type_declaration|
+                                       domain.foobara_type_from_declaration(element_type_declaration)
+                                     end
                                    end
                                  end
-                               end
+          end
         end
       end
     end

data/projects/type_declarations/src/type_builder.rb

@@ -129,7 +129,7 @@ module Foobara
       end
 
       def type_for_declaration(*type_declaration_bits, &block)
-        lru_cache.cached([type_declaration_bits, block]) do
+        lru_cache.cached([self, *block&.object_id, *type_declaration_bits]) do
           type_for_declaration_without_cache(*type_declaration_bits, &block)
         end
       rescue NoTypeDeclarationHandlerFoundError
@@ -152,16 +152,10 @@ module Foobara
         handler.process_value!(type_declaration)
       end
 
-      def clear_cache
-        if @lru_cache
-          lru_cache.reset!
-        end
-      end
-
       private
 
       def lru_cache
-        @lru_cache ||= Foobara::LruCache.new(100)
+        Namespace::IsNamespace.lru_cache
       end
     end
   end

data/projects/types/src/type.rb

@@ -20,7 +20,9 @@ module Foobara
                     :name,
                     :description,
                     :sensitive,
-                    :sensitive_exposed
+                    :sensitive_exposed,
+                    :element_type_loader,
+                    :element_types_loader
 
       attr_reader :type_symbol,
                   :casters,
@@ -44,8 +46,6 @@ module Foobara
         transformers: [],
         validators: [],
         element_processors: nil,
-        element_type: nil,
-        element_types: nil,
         structure_count: nil,
         processor_classes_requiring_type: nil,
         sensitive: nil,
@@ -64,9 +64,6 @@ module Foobara
         self.element_processors = [*element_processors, *base_type&.element_processors]
 
         self.structure_count = structure_count
-        # TODO: combine these maybe with the term "children_types"?
-        self.element_types = element_types
-        self.element_type = element_type
         self.target_classes = Util.array(target_classes)
         self.processor_classes_requiring_type = processor_classes_requiring_type
 
@@ -95,23 +92,23 @@ module Foobara
       end
 
       def element_type
-        type = @element_type || base_type&.element_type
-
-        if type.is_a?(::Symbol)
-          type = @element_type = TypeDeclarations::LazyElementTypes.const_get(type).resolve(self)
+        lru_cache.cached([self, :element_type]) do
+          if element_type_loader
+            element_type_loader.resolve(self)
+          else
+            base_type&.element_type
+          end
         end
-
-        type
       end
 
       def element_types
-        types = @element_types || base_type&.element_types
-
-        if types.is_a?(::Symbol)
-          types = @element_types = TypeDeclarations::LazyElementTypes.const_get(types).resolve(self)
+        lru_cache.cached([self, :element_types]) do
+          if element_types_loader
+            element_types_loader.resolve(self)
+          else
+            base_type&.element_types
+          end
         end
-
-        types
       end
 
       def has_sensitive_types?

data/version.rb

@@ -1,6 +1,6 @@
 module Foobara
   module Version
-    VERSION = "0.1.9".freeze
+    VERSION = "0.1.11".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.9
+  version: 0.1.11
 platform: ruby
 authors:
 - Miles Georgi