foobara 0.0.141 → 0.1.1

data/projects/model/src/extensions/type_declarations/handlers/extend_registered_model_type_declaration/hash_desugarizer.rb

@@ -1,21 +1,20 @@
 module Foobara
   module TypeDeclarations
     module Handlers
+      # TODO: Can't we just delete this type entirely?
       class ExtendRegisteredModelTypeDeclaration < ExtendRegisteredTypeDeclaration
         class HashDesugarizer < TypeDeclarations::Desugarizer
           def applicable?(sugary_type_declaration)
-            return false unless sugary_type_declaration.is_a?(::Hash)
+            return false unless sugary_type_declaration.hash?
 
             type_symbol = sugary_type_declaration[:type]
 
-            if type_symbol
-              if type_symbol.is_a?(::Symbol) && type_registered?(type_symbol)
-                type = Foobara.foobara_root_namespace.foobara_lookup_type(
-                  type_symbol, mode: Namespace::LookupMode::ABSOLUTE
-                )
+            if type_symbol.is_a?(::Symbol)
+              # TODO: cache this on a #base_type= helper
+              type = sugary_type_declaration.type ||
+                     lookup_type(type_symbol, mode: Namespace::LookupMode::ABSOLUTE)
 
-                type&.extends?(BuiltinTypes[expected_type_symbol])
-              end
+              type&.extends?(BuiltinTypes[expected_type_symbol])
             end
           end
 
@@ -24,7 +23,7 @@ module Foobara
           end
 
           def desugarize(sugary_type_declaration)
-            Util.symbolize_keys(sugary_type_declaration)
+            sugary_type_declaration.symbolize_keys!
           end
 
           def priority

data/projects/model/src/extensions/type_declarations/handlers/extend_registered_model_type_declaration/model_class_type_desugarizer.rb

@@ -4,7 +4,7 @@ module Foobara
       class ExtendRegisteredModelTypeDeclaration < ExtendRegisteredTypeDeclaration
         class ModelClassTypeDesugarizer < TypeDeclarations::Desugarizer
           def applicable?(sugary_type_declaration)
-            if sugary_type_declaration.is_a?(::Hash) && sugary_type_declaration.key?(:type)
+            if sugary_type_declaration.hash? && sugary_type_declaration.key?(:type)
               type = sugary_type_declaration[:type]
               type.is_a?(::Class) && type < Model
             end
@@ -12,7 +12,11 @@ module Foobara
 
           def desugarize(hash)
             model_class = hash[:type]
-            hash.merge(type: model_class.model_type.foobara_manifest_reference.to_sym)
+            hash[:type] = model_class.model_type.foobara_manifest_reference.to_sym
+
+            hash.handle_symbolic_declaration
+
+            hash
           end
 
           def priority

data/projects/model/src/extensions/type_declarations/handlers/extend_registered_model_type_declaration/mutable_validator.rb

@@ -21,9 +21,12 @@ module Foobara
 
           def validation_errors(strict_type_declaration)
             mutable = strict_type_declaration[:mutable]
-            return if [true, false].include?(mutable)
+            return if mutable == true || mutable == false
+
+            model_type = strict_type_declaration.type
+
+            model_type ||= type_for_declaration(strict_type_declaration[:type])
 
-            model_type = type_for_declaration(strict_type_declaration[:type])
             valid_attribute_names = model_type.element_types.element_types.keys
 
             mutable.map do |key|

data/projects/model/src/extensions/type_declarations/handlers/extend_registered_model_type_declaration/normalize_mutable_attributes_desugarizer.rb

@@ -4,22 +4,23 @@ module Foobara
       class ExtendRegisteredModelTypeDeclaration < ExtendRegisteredTypeDeclaration
         class NormalizeMutableAttributesDesugarizer < TypeDeclarations::Desugarizer
           def applicable?(value)
-            if value.is_a?(::Hash) && value.key?(:mutable) && value.key?(:type)
+            if value.hash? && value.key?(:mutable) && value.key?(:type)
               mutable = value[:mutable]
 
-              return false if [true, false].include?(mutable)
+              return false if mutable == true || mutable == false
 
               if !mutable.is_a?(::Array) || (mutable.is_a?(::Array) && mutable.any? { |k| !k.is_a?(::Symbol) })
-                type = type_for_declaration(value[:type])
-                type.extends?(BuiltinTypes[:model])
+                type = value.type ||
+                       lookup_type(value[:type], mode: Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE)
+
+                type&.extends?(BuiltinTypes[:model])
               end
             end
           end
 
           def desugarize(rawish_type_declaration)
-            rawish_type_declaration.merge(
-              mutable: Util.array(rawish_type_declaration[:mutable]).map!(&:to_sym)
-            )
+            rawish_type_declaration[:mutable] = Util.array(rawish_type_declaration[:mutable]).map!(&:to_sym)
+            rawish_type_declaration
           end
         end
       end

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

@@ -2,6 +2,7 @@ module Foobara
   module TypeDeclarations
     module Handlers
       class ExtendRegisteredModelTypeDeclaration < ExtendRegisteredTypeDeclaration
+        # TODO: seems like we can delete this handler entirely?
         class ToTypeTransformer < ExtendRegisteredTypeDeclaration::ToTypeTransformer
           # TODO: make declaration validator for model_class and model_base_class
           def target_classes(strict_type_declaration)
@@ -14,7 +15,9 @@ module Foobara
           end
 
           def declaration_to_type(strict_type_declaration)
-            type_for_declaration(strict_type_declaration[:type])
+            # TODO: cache this on a #base_type= helper
+            strict_type_declaration.type ||
+              lookup_type(strict_type_declaration[:type], mode: Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE)
           end
         end
       end

data/projects/model/src/extensions/type_declarations/handlers/extend_registered_model_type_declaration.rb

@@ -4,17 +4,32 @@ module Foobara
       # Why doesn't this inherit from ExtendModelTypeDeclaration
       class ExtendRegisteredModelTypeDeclaration < ExtendRegisteredTypeDeclaration
         def applicable?(sugary_type_declaration)
-          strict_type_declaration = desugarize(sugary_type_declaration)
+          strict_type_declaration = if sugary_type_declaration.strict?
+                                      # :nocov:
+                                      sugary_type_declaration
+                                      # :nocov:
+                                    else
+                                      desugarize(sugary_type_declaration.clone)
+                                    end
 
-          if strict_type_declaration.is_a?(::Hash) && strict_type_declaration.key?(:type)
+          if strict_type_declaration.hash? && strict_type_declaration.key?(:type)
             type_symbol = strict_type_declaration[:type]
 
             return false if type_symbol == expected_type_symbol
             return false unless type_symbol.is_a?(::Symbol) || type_symbol.is_a?(::String)
 
-            if type_registered?(type_symbol)
-              type = lookup_type!(type_symbol)
-              type.extends?(BuiltinTypes[expected_type_symbol])
+            # TODO: cache this on a #base_type= helper
+            type = strict_type_declaration.type ||
+                   lookup_type(type_symbol, mode: Namespace::LookupMode::ABSOLUTE)
+
+            if type
+              if type.extends?(BuiltinTypes[expected_type_symbol])
+                unless sugary_type_declaration.equal?(strict_type_declaration)
+                  sugary_type_declaration.assign(strict_type_declaration)
+                end
+
+                true
+              end
             end
           end
         end

data/projects/model/src/extensions/type_declarations/handlers/registered_type_declaration/model_class_desugarizer.rb

@@ -4,13 +4,31 @@ module Foobara
       class RegisteredTypeDeclaration < TypeDeclarationHandler
         class ModelClassDesugarizer < TypeDeclarations::Desugarizer
           def applicable?(sugary_type_declaration)
-            sugary_type_declaration.is_a?(Class) && sugary_type_declaration < Model
+            sugary_type_declaration.class? && sugary_type_declaration.declaration_data < Model
           end
 
-          def desugarize(model_class)
-            {
-              type: model_class.model_type.foobara_manifest_reference.to_sym
-            }
+          def desugarize(declaration)
+            model_class = declaration.declaration_data
+
+            declaration.declaration_data = model_class.model_type.foobara_manifest_reference.to_sym
+
+            type = model_class.model_type
+
+            if type
+              declaration.type = type
+              declaration.reference_checked = true
+            else
+              # :nocov:
+              declaration.reference_checked = false
+              # :nocov:
+            end
+
+            declaration.is_absolutified = true
+            declaration.is_strict = true
+            declaration.is_duped = true
+            declaration.is_deep_duped = true
+
+            declaration
           end
 
           def priority

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

@@ -0,0 +1,18 @@
+module Foobara
+  module TypeDeclarations
+    module LazyElementTypes
+      module Model
+        module_function
+
+        def resolve(type)
+          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))
+          end
+        end
+      end
+    end
+  end
+end

data/projects/model_attribute_helpers/src/attribute_helpers.rb

@@ -54,7 +54,7 @@ module Foobara
               end
 
               unless include_delegates
-                declaration = Foobara::TypeDeclarations::Attributes.reject(declaration, *delegates.keys)
+                declaration = Foobara::TypeDeclarations::Attributes.reject(declaration, *foobara_delegates.keys)
               end
 
               Domain.current.foobara_type_from_declaration(declaration)
@@ -80,9 +80,11 @@ module Foobara
               if type.extends?(BuiltinTypes[:entity])
                 target_class = type.target_class
 
-                entry = foobara_type_declaration_value_at(declaration, DataPath.new(data_path).path)
-                entry.clear
-                entry.merge!(target_class.foobara_attributes_for_aggregate_update(initial: false))
+                set_foobara_type_declaration_value_at(
+                  declaration,
+                  DataPath.new(data_path).path,
+                  target_class.foobara_attributes_for_aggregate_update(initial: false)
+                )
               end
             end
 
@@ -111,9 +113,12 @@ module Foobara
                 # TODO: do we really need declaration_data? Why cant we use the type directly?
                 # TODO: make this work with the type directly for performance reasons.
                 primary_key_type_declaration = target_class.foobara_primary_key_type.declaration_data
-                entry = foobara_type_declaration_value_at(declaration, DataPath.new(data_path).path)
-                entry.clear
-                entry.merge!(primary_key_type_declaration)
+
+                set_foobara_type_declaration_value_at(
+                  declaration,
+                  DataPath.new(data_path).path,
+                  primary_key_type_declaration
+                )
               end
             end
 
@@ -131,31 +136,44 @@ module Foobara
               TypeDeclarations::Handlers::ExtendAttributesTypeDeclaration
             )
 
-            handler.desugarize(
-              type: "::attributes",
-              element_type_declarations:
-            )
+            declaration = TypeDeclaration.new(type: :attributes, element_type_declarations:)
+            declaration.is_absolutified = true
+            declaration.is_duped = true
+
+            handler.desugarize(declaration).declaration_data
           end
 
           private
 
-          def foobara_type_declaration_value_at(declaration, path_parts)
-            return declaration if path_parts.empty?
-
+          def set_foobara_type_declaration_value_at(declaration, path_parts, value)
             path_part, *path_parts = path_parts
 
-            declaration = case path_part
-                          when :"#"
-                            declaration[:element_type_declaration]
-                          when Symbol, Integer
-                            declaration[:element_type_declarations][path_part]
-                          else
-                            # :nocov:
-                            raise "Bad path part #{path_part}"
-                            # :nocov:
-                          end
-
-            foobara_type_declaration_value_at(declaration, path_parts)
+            case path_part
+            when :"#"
+              if path_parts.empty?
+                declaration[:element_type_declaration] = value
+              else
+                set_foobara_type_declaration_value_at(
+                  declaration[:element_type_declaration],
+                  path_parts,
+                  value
+                )
+              end
+            when Symbol, Integer
+              if path_parts.empty?
+                declaration[:element_type_declarations][path_part] = value
+              else
+                set_foobara_type_declaration_value_at(
+                  declaration[:element_type_declarations][path_part],
+                  path_parts,
+                  value
+                )
+              end
+            else
+              # :nocov:
+              raise "Bad path part #{path_part}"
+              # :nocov:
+            end
           end
         end
       end

data/projects/namespace/src/is_namespace.rb

@@ -3,6 +3,16 @@ require_relative "scoped"
 module Foobara
   class Namespace
     module IsNamespace
+      class << self
+        def lru_cache
+          @lru_cache ||= Foobara::LruCache.new(100)
+        end
+
+        def clear_lru_cache!
+          @lru_cache = nil
+        end
+      end
+
       include Scoped
 
       def scoped_clear_caches
@@ -88,8 +98,13 @@ module Foobara
         scopedish
       end
 
+      # TODO: make this thread-safe
       def foobara_register(scoped)
         foobara_registry.register(scoped)
+
+        # TODO: do we really need to clear the whole cache? Why not just the possible
+        # impacted keys based on scoped.scoped_path ?
+        IsNamespace.clear_lru_cache!
         # awkward??
         scoped.scoped_namespace = self
 
@@ -108,6 +123,8 @@ module Foobara
         foobara_registry.unregister(scoped)
         foobara_children.delete(scoped)
         scoped.scoped_namespace = nil
+
+        IsNamespace.clear_lru_cache!
       end
 
       def foobara_unregister_all
@@ -116,33 +133,33 @@ module Foobara
         end
       end
 
-      def foobara_lookup(
-        path,
-        filter: nil,
-        mode: LookupMode::GENERAL,
-        visited: Set.new,
-        initial: true
-      )
+      def lru_cache
+        IsNamespace.lru_cache
+      end
+
+      def foobara_lookup(path, filter: nil, mode: LookupMode::GENERAL)
+        LookupMode.validate!(mode)
         path = Namespace.to_registry_path(path)
-        visited_key = [path, mode, initial, self]
+
+        lru_cache.cached([path, mode, self, filter]) do
+          visited = Set.new
+          foobara_lookup_without_cache(path, filter:, mode:, visited:)
+        end
+      end
+
+      def foobara_lookup_without_cache(path, filter:, mode:, visited:)
+        visited_key = [path, mode, self]
         return nil if visited.include?(visited_key)
 
         visited << visited_key
 
-        LookupMode.validate!(mode)
-
         if mode == LookupMode::RELAXED
-          scoped = foobara_lookup(
-            path,
-            filter:,
-            mode: LookupMode::GENERAL,
-            visited:,
-            initial: false
-          )
+          scoped = foobara_lookup_without_cache(path, filter:, mode: LookupMode::GENERAL, visited:)
+
           return scoped if scoped
 
           candidates = foobara_children.map do |namespace|
-            namespace.foobara_lookup(path, filter:, mode:, visited:, initial: false)
+            namespace.foobara_lookup_without_cache(path, filter:, mode:, visited:)
           end.compact
 
           if candidates.size > 1
@@ -152,8 +169,10 @@ module Foobara
             # :nocov:
           end
 
-          return candidates.first ||
-                 foobara_parent_namespace&.foobara_lookup(path, filter:, mode:, visited:, initial: false)
+          scoped = candidates.first ||
+                   foobara_parent_namespace&.foobara_lookup_without_cache(path, filter:, mode:, visited:)
+
+          return scoped
         end
 
         if path[0] == ""
@@ -165,7 +184,31 @@ module Foobara
             path = path[(foobara_root_namespace.scoped_path.size + 1)..]
           end
 
-          return foobara_root_namespace.foobara_lookup(path, filter:, mode: LookupMode::ABSOLUTE, initial: true)
+          return foobara_lookup_without_cache(path, filter:, mode: LookupMode::ABSOLUTE, visited:)
+        end
+
+        root = foobara_root_namespace
+
+        if mode == LookupMode::ABSOLUTE
+          [
+            root,
+            *root.foobara_depends_on_namespaces.map(&:foobara_root_namespace)
+          ].uniq.each do |namespace|
+            scoped = namespace.foobara_lookup_without_cache(path,
+                                                            filter:,
+                                                            mode: LookupMode::CHILDREN_ONLY,
+                                                            visited:)
+            return scoped if scoped
+          end
+
+          return nil
+        end
+
+        if mode == LookupMode::ABSOLUTE_SINGLE_NAMESPACE
+          return foobara_root_namespace.foobara_lookup_without_cache(path,
+                                                                     filter:,
+                                                                     mode: LookupMode::CHILDREN_ONLY,
+                                                                     visited:)
         end
 
         partial = foobara_registry.lookup(path, filter)
@@ -187,18 +230,27 @@ module Foobara
         end
 
         scoped = _lookup_in(path, to_consider, filter:, visited:)
-        return scoped if scoped
 
-        if [LookupMode::GENERAL, LookupMode::STRICT].include?(mode) && foobara_parent_namespace
-          scoped = foobara_parent_namespace.foobara_lookup(
-            path, filter:, mode: LookupMode::STRICT, visited:, initial: false
+        if scoped
+          return scoped
+        end
+
+        if (mode == LookupMode::GENERAL || mode == LookupMode::STRICT) && foobara_parent_namespace
+          scoped = foobara_parent_namespace.foobara_lookup_without_cache(
+            path, filter:, mode: LookupMode::STRICT, visited:
           )
-          return scoped if scoped
+
+          if scoped
+            return scoped
+          end
         end
 
         if mode == LookupMode::GENERAL
           scoped = _lookup_in(path, foobara_depends_on_namespaces, filter:, visited:)
-          return scoped if scoped
+
+          if scoped
+            return scoped
+          end
         end
 
         to_consider = case mode
@@ -209,7 +261,7 @@ module Foobara
                       end
 
         candidates = to_consider.map do |namespace|
-          namespace.foobara_lookup(path, filter:, mode:, visited:, initial: false)
+          namespace.foobara_lookup_without_cache(path, filter:, mode:, visited:)
         end.compact
 
         if candidates.size > 1
@@ -218,19 +270,7 @@ module Foobara
           # :nocov:
         end
 
-        scoped = candidates.first || partial
-        return scoped if scoped
-
-        # As a last resort we'll see if we're trying to fetch a builtin type from a different namespace
-        # TODO: these lookup modes are really confusing and were designed prior to having multiple root
-        # namespaces playing a role in command connectors.
-        if initial
-          scoped = Namespace.global.foobara_lookup(path, filter:, mode: LookupMode::ABSOLUTE, visited:, initial: false)
-
-          if scoped.is_a?(Types::Type) && scoped.builtin?
-            scoped
-          end
-        end
+        candidates.first || partial
       end
 
       def foobara_parent_namespace
@@ -252,9 +292,10 @@ module Foobara
       def foobara_each(filter: nil, mode: Namespace::LookupMode::GENERAL, &)
         foobara_registry.each_scoped(filter:, &)
 
-        return if mode == Namespace::LookupMode::DIRECT
-
-        if [Namespace::LookupMode::GENERAL, Namespace::LookupMode::ABSOLUTE].include?(mode)
+        if mode == LookupMode::GENERAL ||
+           mode == LookupMode::CHILDREN_ONLY ||
+           mode == LookupMode::ABSOLUTE ||
+           mode == LookupMode::ABSOLUTE_SINGLE_NAMESPACE
           foobara_children.each do |child|
             child.foobara_each(filter:, mode:, &)
           end
@@ -338,6 +379,10 @@ module Foobara
                                Foobara::Namespace::UnambiguousRegistry
                              when Foobara::Namespace::BaseRegistry::WouldMakeRegistryAmbiguousError
                                Foobara::Namespace::AmbiguousRegistry
+                             else
+                               # :nocov:
+                               raise ArgumentError, "Not sure how to upgrade a #{error.class}"
+                               # :nocov:
                              end
 
         old_registry = foobara_registry
@@ -366,19 +411,18 @@ module Foobara
         end
 
         matching_children.sort_by(&:first).reverse.each do |(matching_child_score, matching_child)|
-          scoped = matching_child.foobara_lookup(
+          scoped = matching_child.foobara_lookup_without_cache(
             path[matching_child_score..],
-            mode: LookupMode::ABSOLUTE,
+            mode: LookupMode::CHILDREN_ONLY,
             filter:,
-            visited:,
-            initial: false
+            visited:
           )
 
           return scoped if scoped
         end
 
         last_resort.uniq.each do |namespace|
-          scoped = namespace.foobara_lookup(path, filter:, mode: LookupMode::ABSOLUTE, visited:, initial: false)
+          scoped = namespace.foobara_lookup_without_cache(path, filter:, mode: LookupMode::CHILDREN_ONLY, visited:)
           return scoped if scoped
         end
 

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

@@ -1,6 +1,6 @@
 module Foobara
   class Namespace
-    # TODO: need to define these better...
+    # TODO: need to define these better/more intuitively
     # use-cases
     # 1. general: just general lookup. find it wherever the heck it might be
     #   children: y
@@ -17,6 +17,14 @@ module Foobara
     # 4. absolute
     #   children: y
     #   parent: n
+    #   dependent: y
+    # 5. absolute_single_namespace
+    #   children: y
+    #   parent: n
+    #   dependent: n
+    # 6. children_only (internal use... absolute and absolute_single_namespace jump to top, children only does not)
+    #   children: y
+    #   parent: n
     #   dependent: n
     # TODO: don't we have an enumerated class/project for this?
     module LookupMode
@@ -25,7 +33,10 @@ module Foobara
       DIRECT = :direct
       STRICT = :strict
       ABSOLUTE = :absolute
-      ALL = [GENERAL, RELAXED, DIRECT, STRICT, ABSOLUTE].freeze
+      ABSOLUTE_SINGLE_NAMESPACE = :absolute_single_namespace
+      CHILDREN_ONLY = :children_only
+
+      ALL = [GENERAL, RELAXED, DIRECT, STRICT, ABSOLUTE, ABSOLUTE_SINGLE_NAMESPACE, CHILDREN_ONLY].freeze
 
       class << self
         def validate!(mode)

data/projects/namespace/src/namespace_helpers.rb

@@ -243,6 +243,7 @@ module Foobara
           # I guess we could just iterate over all objects and patch up any with matching prefixes?
           # is this expensive to have to look at all of them or no? I guess at least it's a one-time thing.
           # TODO: somehow look things up by prefixes since we know mod's path
+          # TODO: can't there be multiple namespace roots??
           Foobara.foobara_root_namespace.foobara_each do |scoped|
             parent = scoped.scoped_namespace
             next if parent == mod

data/projects/namespace/src/prefixless_registry.rb

@@ -41,6 +41,8 @@ module Foobara
         registry.each_value(&)
       end
 
+      private
+
       def to_key(scoped)
         if scoped.scoped_prefix
           raise RegisteringScopedWithPrefixError,

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

@@ -80,7 +80,26 @@ module Foobara
 
             # TODO: this belongs elsewhere
             def each_table(&)
-              tables.values.each(&)
+              @ordered_tables ||= if tables.size <= 1
+                                    tables.values
+                                  else
+                                    entity_class_to_table = {}
+                                    entity_classes = []
+
+                                    tables.each_value do |table|
+                                      entity_class = table.entity_class
+                                      entity_classes << entity_class
+                                      entity_class_to_table[entity_class] = table
+                                    end
+
+                                    ordered_entity_classes = EntityBase.order_entity_classes(entity_classes)
+
+                                    ordered_entity_classes.map do |entity_class|
+                                      entity_class_to_table[entity_class]
+                                    end
+                                  end
+
+              @ordered_tables.each(&)
             end
 
             def rollback!(because_of = nil)