foobara 0.0.142 → 0.1.2

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

@@ -98,9 +98,12 @@ 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
@@ -134,48 +137,29 @@ module Foobara
         IsNamespace.lru_cache
       end
 
-      def foobara_lookup(
-        path,
-        filter: nil,
-        mode: LookupMode::GENERAL,
-        visited: nil,
-        initial: true
-      )
-        # TODO: make it so this is only necessary when initial
+      def foobara_lookup(path, filter: nil, mode: LookupMode::GENERAL)
+        LookupMode.validate!(mode)
         path = Namespace.to_registry_path(path)
-        visited_key = [path, mode, initial, self]
 
-        if initial
-          lru_key = [path, mode, self, filter]
-          found, value = lru_cache.get(lru_key)
-          return value if found
+        lru_cache.cached([path, mode, self, filter]) do
+          visited = Set.new
+          foobara_lookup_without_cache(path, filter:, mode:, visited:)
         end
+      end
 
-        return nil if visited&.include?(visited_key)
+      def foobara_lookup_without_cache(path, filter:, mode:, visited:)
+        visited_key = [path, mode, self]
+        return nil if visited.include?(visited_key)
 
-        visited ||= Set.new
         visited << visited_key
 
-        LookupMode.validate!(mode)
-
         if mode == LookupMode::RELAXED
-          scoped = foobara_lookup(
-            path,
-            filter:,
-            mode: LookupMode::GENERAL,
-            visited:,
-            initial: false
-          )
-          if scoped
-            if initial
-              lru_cache.set_if_missing(lru_key, scoped)
-            end
+          scoped = foobara_lookup_without_cache(path, filter:, mode: LookupMode::GENERAL, visited:)
 
-            return scoped
-          end
+          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
@@ -186,11 +170,7 @@ module Foobara
           end
 
           scoped = candidates.first ||
-                   foobara_parent_namespace&.foobara_lookup(path, filter:, mode:, visited:, initial: false)
-
-          if initial
-            lru_cache.set_if_missing(lru_key, scoped)
-          end
+                   foobara_parent_namespace&.foobara_lookup_without_cache(path, filter:, mode:, visited:)
 
           return scoped
         end
@@ -204,25 +184,41 @@ 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)
 
         if mode == LookupMode::DIRECT
-          if initial
-            lru_cache.set_if_missing(lru_key, partial)
-          end
-
           return partial
         end
 
         if partial
           if partial.scoped_path == path
-            if initial
-              lru_cache.set_if_missing(lru_key, partial)
-            end
-
             return partial
           end
         end
@@ -236,23 +232,15 @@ module Foobara
         scoped = _lookup_in(path, to_consider, filter:, visited:)
 
         if scoped
-          if initial
-            lru_cache.set_if_missing(lru_key, scoped)
-          end
-
           return scoped
         end
 
-        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 (mode == LookupMode::GENERAL || mode == LookupMode::STRICT) && foobara_parent_namespace
+          scoped = foobara_parent_namespace.foobara_lookup_without_cache(
+            path, filter:, mode: LookupMode::STRICT, visited:
           )
 
           if scoped
-            if initial
-              lru_cache.set_if_missing(lru_key, scoped)
-            end
-
             return scoped
           end
         end
@@ -261,10 +249,6 @@ module Foobara
           scoped = _lookup_in(path, foobara_depends_on_namespaces, filter:, visited:)
 
           if scoped
-            if initial
-              lru_cache.set_if_missing(lru_key, scoped)
-            end
-
             return scoped
           end
         end
@@ -277,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
@@ -286,27 +270,7 @@ module Foobara
           # :nocov:
         end
 
-        scoped = candidates.first || partial
-
-        if scoped
-          if initial
-            lru_cache.set_if_missing(lru_key, scoped)
-          end
-
-          return scoped
-        end
-
-        # 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?
-            lru_cache.set_if_missing(lru_key, scoped)
-            scoped
-          end
-        end
+        candidates.first || partial
       end
 
       def foobara_parent_namespace
@@ -328,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
@@ -414,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
@@ -442,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)

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

@@ -62,7 +62,20 @@ module Foobara
             # :nocov:
           end
 
-          tables[entity_class] ||= TransactionTable.new(self, entity_class)
+          table = tables[entity_class]
+
+          if table
+            table
+          else
+            if defined?(@ordered_tables)
+              # TODO: test this path
+              # :nocov:
+              remove_instance_variable(:@ordered_tables)
+              # :nocov:
+            end
+
+            tables[entity_class] = TransactionTable.new(self, entity_class)
+          end
         end
 
         def updated(record)
@@ -149,16 +162,6 @@ module Foobara
           table_for(entity).track_created(entity)
         end
 
-        def created?(record)
-          table_for(record).created?(record)
-        end
-
-        # WARNING! this seems to bypass validations, hmmm....
-        def flush_created_record!(record)
-          table_for(record).flush_created_record!(record)
-        end
-
-        # convenience method...
         def perform(&)
           entity_base.using_transaction(self, &)
         end

data/projects/persistence/src/entity_base/transaction_table.rb

@@ -642,11 +642,12 @@ module Foobara
 
         def flush_created!
           marked_created.each do |record|
-            flush_created_associations!(record)
-
             # TODO: do this in bulk
             attributes = entity_attributes_crud_driver_table.insert(to_persistable(record))
-            record.write_attributes_without_callbacks(attributes)
+            primary_key_attribute = entity_class.primary_key_attribute
+            primary_key = attributes[primary_key_attribute]
+
+            record.write_attributes_without_callbacks(primary_key_attribute => primary_key)
 
             # we need to update finding the tracked object by key and removing/reading it seems to be the simplest
             # way to accomplish that at the moment
@@ -660,48 +661,10 @@ module Foobara
           marked_created.clear
         end
 
-        def flush_created_record!(record)
-          flush_created_associations!(record)
-
-          unmark_created(record)
-
-          attributes = entity_attributes_crud_driver_table.insert(to_persistable(record))
-          record.write_attributes_without_callbacks(attributes)
-
-          # we need to update finding the tracked object by key and removing/reading it seems to be the simplest
-          # way to accomplish that at the moment
-          tracked(record)
-
-          record.is_persisted = record.is_loaded = true
-          record.is_created = false
-          record.save_persisted_attributes
-        end
-
-        def flush_created_associations!(record)
-          entity_class.associations.each_key do |association_data_path|
-            DataPath.values_at(association_data_path, record).each do |associated_record|
-              next unless associated_record.created?
-
-              transaction = Persistence::EntityBase::Transaction.open_transaction_for(associated_record)
-
-              unless transaction
-                # :nocov:
-                raise "No open transaction for #{associated_record}"
-                # :nocov:
-              end
-
-              if transaction.created?(associated_record)
-                transaction.flush_created_record!(associated_record)
-              end
-            end
-          end
-        end
-
         def flush_updated_and_hard_deleted!
           # TODO: use bulk operations to improve performance...
           marked_updated.each do |record|
-            attributes = entity_attributes_crud_driver_table.update(to_persistable(record))
-            record.write_attributes_without_callbacks(attributes)
+            entity_attributes_crud_driver_table.update(to_persistable(record))
             record.save_persisted_attributes
           end
 
@@ -753,16 +716,14 @@ module Foobara
 
         def normalize_attributes(attributes)
           if attributes
-            begin
-              attributes = attributes.transform_keys(&:to_sym)
+            attributes = attributes.transform_keys(&:to_sym)
 
-              primary_key_name = entity_class.primary_key_attribute
-              primary_key_value = attributes[primary_key_name]
+            primary_key_name = entity_class.primary_key_attribute
+            primary_key_value = attributes[primary_key_name]
 
-              attributes[primary_key_name] = entity_class.primary_key_type.cast!(primary_key_value)
+            attributes[primary_key_name] = entity_class.primary_key_type.cast!(primary_key_value)
 
-              attributes
-            end
+            attributes
           end
         end
       end

data/projects/persistence/src/entity_base.rb

@@ -21,6 +21,45 @@ module Foobara
             end.call
           end
         end
+
+        def order_entity_classes(entity_classes)
+          return entity_classes if entity_classes.size <= 1
+
+          without_associations, with_associations = entity_classes.partition do |entity_class|
+            entity_class.associations.empty?
+          end
+
+          if with_associations.size > 1
+            i = 0
+            end_at = with_associations.size - 1
+
+            while i < end_at
+              entity_class = with_associations[i]
+              associations = entity_class.associations.values.uniq
+
+              changed = false
+
+              j = i + 1
+
+              while j <= end_at
+                other = with_associations[j]
+
+                if associations.include?(other.foobara_type)
+                  with_associations[j] = entity_class
+                  with_associations[i] = other
+                  changed = true
+                  break
+                end
+
+                j += 1
+              end
+
+              i += 1 unless changed
+            end
+          end
+
+          without_associations + with_associations
+        end
       end
 
       def initialize(name, entity_attributes_crud_driver:)

data/projects/persistence/src/persistence.rb

@@ -99,6 +99,10 @@ module Foobara
       end
 
       def objects_to_bases(objects)
+        if objects.size > 1 && objects.all? { |o| o.is_a?(::Class) && o < Entity }
+          objects = EntityBase.order_entity_classes(objects)
+        end
+
         objects.map do |object|
           object_to_base(object)
         end.uniq