foobara 0.0.92 → 0.0.93

data/projects/common/src/error.rb

@@ -102,9 +102,13 @@ module Foobara
         }
       end
 
-      def foobara_manifest(to_include: Set.new, remove_sensitive: false)
-        types = types_depended_on(remove_sensitive:).map do |t|
-          to_include << t
+      def foobara_manifest
+        to_include = TypeDeclarations.foobara_manifest_context_to_include
+
+        types = types_depended_on.map do |t|
+          if to_include
+            to_include << t
+          end
           t.foobara_manifest_reference
         end
 
@@ -112,7 +116,9 @@ module Foobara
         # don't bother including these core errors
         unless superclass == Foobara::Error
           base = superclass
-          to_include << base
+          if to_include
+            to_include << base
+          end
         end
 
         manifest = super

data/projects/common/src/possible_error.rb

@@ -46,12 +46,18 @@ module Foobara
     end
 
     # TODO: technically does not belong in this project but maybe it should
-    def foobara_manifest(to_include: Set.new, remove_sensitive: false)
-      to_include << error_class
+    def foobara_manifest
+      to_include = TypeDeclarations.foobara_manifest_context_to_include
+
+      if to_include
+        to_include << error_class
+      end
 
       if processor
         processor_class = processor.class
-        to_include << processor_class
+        if to_include
+          to_include << processor_class
+        end
 
         if processor.scoped_path_set?
           # Unclear why nothing in the test suite passes through here.

data/projects/detached_entity/src/concerns/associations.rb

@@ -5,18 +5,22 @@ module Foobara
         include Concern
 
         module ClassMethods
-          def foobara_associations(remove_sensitive: false)
+          def foobara_associations
+            remove_sensitive = TypeDeclarations.foobara_manifest_context_remove_sensitive?
+
             if defined?(@foobara_associations) && @foobara_associations.key?(remove_sensitive)
               return @foobara_associations[remove_sensitive]
             end
 
             @foobara_associations ||= {}
-            @foobara_associations[remove_sensitive] = construct_associations(remove_sensitive:)
+            @foobara_associations[remove_sensitive] = construct_associations
           end
 
           alias associations foobara_associations
 
-          def foobara_deep_associations(remove_sensitive: false)
+          def foobara_deep_associations
+            remove_sensitive = TypeDeclarations.foobara_manifest_context_remove_sensitive?
+
             if defined?(@foobara_deep_associations) && @foobara_deep_associations.key?(remove_sensitive)
               return @foobara_deep_associations[remove_sensitive]
             end
@@ -30,7 +34,7 @@ module Foobara
 
                 entity_class = type.target_class
 
-                entity_class.deep_associations(remove_sensitive:).each_pair do |sub_data_path, sub_type|
+                entity_class.deep_associations.each_pair do |sub_data_path, sub_type|
                   deep["#{data_path}.#{sub_data_path}"] = sub_type
                 end
               end
@@ -126,10 +130,9 @@ module Foobara
           def construct_deep_associations(
             type = attributes_type,
             path = DataPath.new,
-            result = {},
-            remove_sensitive: false
+            result = {}
           )
-            associations = construct_associations(type, path, result, remove_sensitive:)
+            associations = construct_associations(type, path, result)
 
             deep = {}
 
@@ -138,7 +141,7 @@ module Foobara
 
               entity_class = association_type.target_class
 
-              entity_class.deep_associations(remove_sensitive:).each_pair do |sub_data_path, sub_type|
+              entity_class.deep_associations.each_pair do |sub_data_path, sub_type|
                 deep["#{data_path}.#{sub_data_path}"] = sub_type
               end
             end
@@ -151,9 +154,10 @@ module Foobara
           def construct_associations(
             type = attributes_type,
             path = DataPath.new,
-            result = {},
-            remove_sensitive: false
+            result = {}
           )
+            remove_sensitive = TypeDeclarations.foobara_manifest_context_remove_sensitive?
+
             if type.extends?(BuiltinTypes[:entity])
               result[path.to_s] = type
             elsif type.extends?(BuiltinTypes[:tuple])
@@ -167,7 +171,7 @@ module Foobara
               end
 
               element_types&.each&.with_index do |element_type, index|
-                construct_associations(element_type, path.append(index), result, remove_sensitive:)
+                construct_associations(element_type, path.append(index), result)
               end
             elsif type.extends?(BuiltinTypes[:array])
               # TODO: what to do about an associative array type?? Unclear how to make a key from that...
@@ -175,7 +179,7 @@ module Foobara
               element_type = type.element_type
 
               if element_type && (!remove_sensitive || !element_type.sensitive?)
-                construct_associations(element_type, path.append(:"#"), result, remove_sensitive:)
+                construct_associations(element_type, path.append(:"#"), result)
               end
             elsif type.extends?(BuiltinTypes[:attributes]) # TODO: matches attributes itself instead of only subtypes
               type.element_types.each_pair do |attribute_name, element_type|
@@ -183,7 +187,7 @@ module Foobara
                   next
                 end
 
-                construct_associations(element_type, path.append(attribute_name), result, remove_sensitive:)
+                construct_associations(element_type, path.append(attribute_name), result)
               end
             elsif type.extends?(BuiltinTypes[:model])
               target_class = type.target_class
@@ -192,12 +196,12 @@ module Foobara
               attributes_type = target_class.send(method)
 
               if !remove_sensitive || !attributes_type.sensitive?
-                construct_associations(attributes_type, path, result, remove_sensitive:)
+                construct_associations(attributes_type, path, result)
               end
             elsif type.extends?(BuiltinTypes[:associative_array])
               # not going to bother testing this for now
               # :nocov:
-              if contains_associations?(type, remove_sensitive:)
+              if contains_associations?(type)
                 raise "Associative array types with associations in them are not currently supported. " \
                       "Use attributes type if you can or set the key_type and/or value_type to duck type"
               end
@@ -207,7 +211,9 @@ module Foobara
             result
           end
 
-          def contains_associations?(type = entity_type, initial = true, remove_sensitive: false)
+          def contains_associations?(type = entity_type, initial = true)
+            remove_sensitive = TypeDeclarations.foobara_manifest_context_remove_sensitive?
+
             if type.extends?(BuiltinTypes[:detached_entity])
               if initial
                 element_types = type.element_types
@@ -219,7 +225,7 @@ module Foobara
                   # :nocov:
                 end
 
-                contains_associations?(element_types, false, remove_sensitive:)
+                contains_associations?(element_types, false)
               else
                 true
               end
@@ -229,12 +235,12 @@ module Foobara
               element_type = type.element_type
 
               if element_type && (!remove_sensitive || !element_type.sensitive?)
-                contains_associations?(element_type, false, remove_sensitive:)
+                contains_associations?(element_type, false)
               end
             elsif type.extends?(BuiltinTypes[:attributes])
               type.element_types.values.any? do |element_type|
                 if !remove_sensitive || !element_type.sensitive?
-                  contains_associations?(element_type, false, remove_sensitive:)
+                  contains_associations?(element_type, false)
                 end
               end
             elsif type.extends?(BuiltinTypes[:associative_array])
@@ -248,7 +254,7 @@ module Foobara
                 end
 
                 types.any? do |key_or_value_type|
-                  contains_associations?(key_or_value_type, false, remove_sensitive:)
+                  contains_associations?(key_or_value_type, false)
                 end
               end
             end

data/projects/detached_entity/src/concerns/reflection.rb

@@ -17,15 +17,15 @@ module Foobara
             types.map(&:target_class).uniq
           end
 
-          def foobara_manifest(to_include: Set.new, remove_sensitive: false)
-            associations = foobara_associations(remove_sensitive:).map do |(path, type)|
+          def foobara_manifest
+            associations = foobara_associations.map do |(path, type)|
               entity_class = type.target_class
               entity_name = entity_class.foobara_type.scoped_full_name
 
               [path, entity_name]
             end.sort.to_h
 
-            deep_associations = foobara_deep_associations(remove_sensitive:).map do |(path, type)|
+            deep_associations = foobara_deep_associations.map do |(path, type)|
               entity_class = type.target_class
               entity_name = entity_class.foobara_type.scoped_full_name
 

data/projects/detached_entity/src/detached_entity_type.rb

@@ -18,11 +18,12 @@ module Foobara
       end
     end
 
-    def foobara_manifest(to_include: Set.new, remove_sensitive: false)
+    def foobara_manifest
       manifest = super
 
       if detached_context?
         declaration_data = manifest[:declaration_data]
+
         if self.class.type_requires_conversion?(declaration_data[:type])
           declaration_data = declaration_data.merge(type: :detached_entity)
         end
@@ -31,13 +32,17 @@ module Foobara
           declaration_data = declaration_data.merge(model_base_class: "Foobara::DetachedEntity")
         end
 
+        # TODO: remove private attributes, add delegated attributes
+        # re: delegated attribute type... it can be required if required entire way, can be
+        # allow_nil if allow_nil anywhere along the way.
+        # remove private and delegated from the manifest hash.
         manifest = manifest.merge(declaration_data:)
       end
 
       manifest
     end
 
-    def types_to_add_to_manifest(remove_sensitive: false)
+    def types_to_add_to_manifest
       types = super
 
       if detached_context?
@@ -57,7 +62,7 @@ module Foobara
     end
 
     def detached_context?
-      Thread.foobara_var_get("foobara_manifest_context")&.[](:detached)
+      TypeDeclarations.foobara_manifest_context_detached?
     end
   end
 end

data/projects/detached_entity/src/extensions/builtin_types/detached_entity/validators/{attributes_declaration.rb → model_instance_is_valid.rb}

@@ -2,7 +2,7 @@ module Foobara
   module BuiltinTypes
     module DetachedEntity
       module Validators
-        class AttributesDeclaration < Model::Validators::AttributesDeclaration
+        class ModelInstanceIsValid < Model::Validators::ModelInstanceIsValid
           # Why is this here in entity/ instead of in model/?
           def possible_errors
             return [] if parent_declaration_data == { type: expected_type_symbol }

data/projects/domain/src/domain_module_extension.rb

@@ -431,20 +431,28 @@ module Foobara
         end
 
         # TODO: can we kill this skip concept?
-        def foobara_manifest(to_include: Set.new, remove_sensitive: false)
+        def foobara_manifest
+          to_include = TypeDeclarations.foobara_manifest_context_to_include
+
           depends_on = foobara_depends_on.map do |name|
             domain = Domain.to_domain(name)
-            to_include << domain
+            if to_include
+              to_include << domain
+            end
             domain.foobara_manifest_reference
           end.sort
 
           commands = foobara_all_command(mode: Namespace::LookupMode::DIRECT).map do |command_class|
-            to_include << command_class
+            if to_include
+              to_include << command_class
+            end
             command_class.foobara_manifest_reference
           end.sort
 
           types = foobara_all_type(mode: Namespace::LookupMode::DIRECT).map do |type|
-            to_include << type
+            if to_include
+              to_include << type
+            end
             type.foobara_manifest_reference
           end.sort
 

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

@@ -8,46 +8,49 @@ module Foobara
     # in the http connector.
     def manifest
       to_include = Namespace.global.foobara_all_organization.to_set
-      included = {}
 
-      h = {}
+      TypeDeclarations.with_manifest_context(to_include:) do
+        included = {}
 
-      until to_include.empty?
-        object = to_include.first
-        to_include.delete(object)
+        h = {}
 
-        unless object.scoped_path_set?
-          # :nocov:
-          raise "no scoped path set for #{object}"
-          # :nocov:
-        end
+        until to_include.empty?
+          object = to_include.first
+          to_include.delete(object)
 
-        manifest_reference = object.foobara_manifest_reference.to_sym
-        category_symbol = Namespace.global.foobara_category_symbol_for(object)
+          unless object.scoped_path_set?
+            # :nocov:
+            raise "no scoped path set for #{object}"
+            # :nocov:
+          end
 
-        unless category_symbol
-          # :nocov:
-          raise "no category symbol for #{object}"
-          # :nocov:
-        end
+          manifest_reference = object.foobara_manifest_reference.to_sym
+          category_symbol = Namespace.global.foobara_category_symbol_for(object)
 
-        if included.key?(manifest_reference)
-          if included[manifest_reference] == category_symbol
-            next
-          else
+          unless category_symbol
             # :nocov:
-            raise "Collision for #{manifest_reference}: #{included[manifest_reference]} and #{category_symbol}"
+            raise "no category symbol for #{object}"
             # :nocov:
           end
-        end
 
-        cat = h[category_symbol] ||= {}
-        cat[manifest_reference] = object.foobara_manifest(to_include:)
+          if included.key?(manifest_reference)
+            if included[manifest_reference] == category_symbol
+              next
+            else
+              # :nocov:
+              raise "Collision for #{manifest_reference}: #{included[manifest_reference]} and #{category_symbol}"
+              # :nocov:
+            end
+          end
 
-        included[manifest_reference] = category_symbol
-      end
+          cat = h[category_symbol] ||= {}
+          cat[manifest_reference] = object.foobara_manifest
 
-      h.sort.to_h
+          included[manifest_reference] = category_symbol
+        end
+
+        h.sort.to_h
+      end
     end
 
     def all_organizations

data/projects/domain/src/is_manifestable.rb

@@ -37,7 +37,9 @@ module Foobara
       end
     end
 
-    def foobara_manifest(to_include: Set.new, remove_sensitive: false)
+    def foobara_manifest
+      to_include = TypeDeclarations.foobara_manifest_context_to_include
+
       h = {
         scoped_path:,
         scoped_name:,
@@ -57,7 +59,9 @@ module Foobara
         parent_category = Namespace.global.foobara_category_symbol_for(parent)
 
         if parent_category
-          to_include << parent
+          if to_include
+            to_include << parent
+          end
           h[:parent] = [parent_category, parent.foobara_manifest_reference]
         end
       end

data/projects/domain/src/organization_module_extension.rb

@@ -36,9 +36,13 @@ module Foobara
           foobara_all_domain(mode: Namespace::LookupMode::DIRECT)
         end
 
-        def foobara_manifest(to_include: Set.new, remove_sensitive: false)
+        def foobara_manifest
+          to_include = TypeDeclarations.foobara_manifest_context_to_include
+
           domains = foobara_domains.map do |domain|
-            to_include << domain
+            if to_include
+              to_include << domain
+            end
             domain.foobara_manifest_reference
           end.sort
 

data/projects/entity/src/concerns/queries.rb

@@ -91,7 +91,7 @@ module Foobara
           end
 
           def that_owns(record, filters = [])
-            containing_records = that_own(record, filters)
+            containing_records = that_own(record, filters).to_a
 
             unless containing_records.empty?
               if containing_records.size == 1
@@ -107,42 +107,40 @@ module Foobara
           def that_own(record, filters = [])
             association_key = association_for([record.class, *filters])
 
-            data_path = DataPath.new(association_key)
+            possible_direct_owner_path = DataPath.new(association_key)
 
-            done = false
+            # We need to find the second-to-last entity in the association path
+            attribute_path = []
+            owning_entity_class = nil
 
-            containing_records = Util.array(record)
+            begin
+              attribute_path.unshift(possible_direct_owner_path.last)
+              possible_direct_owner_path = DataPath.new(possible_direct_owner_path.path[0..-2])
 
-            until done
-              last = data_path.path.last
+              owning_entity_class = if possible_direct_owner_path.empty?
+                                      self
+                                    else
+                                      deep_associations[possible_direct_owner_path.to_s]&.target_class
+                                    end
+            end until owning_entity_class
 
-              if last == :"#"
-                method = :find_all_by_attribute_containing_any_of
-                attribute_name = data_path.path[-2]
-                data_path = DataPath.new(data_path.path[0..-3])
-              else
-                method = :find_all_by_attribute_any_of
-                attribute_name = last
-                data_path = DataPath.new(data_path.path[0..-2])
-              end
-
-              containing_entity_class_path = data_path.to_s
-
-              entity_class = if containing_entity_class_path.empty?
-                               done = true
-                               self
-                             else
-                               deep_associations[
-                                 containing_entity_class_path
-                               ].target_class
-                             end
-
-              containing_records = entity_class.send(method, attribute_name, containing_records).to_a
-
-              done = true unless containing_records
+            if attribute_path.size == 1
+              attribute_path = attribute_path.first
             end
 
-            containing_records
+            if owning_entity_class == self
+              owning_entity_class.find_all_by_attribute(attribute_path, record)
+            else
+              Enumerator.new do |yielder|
+                owners = owning_entity_class.find_all_by_attribute(attribute_path, record)
+
+                owners.each do |owner|
+                  that_own(owner, filters).each do |r|
+                    yielder.yield(r)
+                  end
+                end
+              end
+            end
           end
         end
       end

data/projects/entity/src/extensions/builtin_types/entity/validators/{attributes_declaration.rb → model_instance_is_valid.rb}

@@ -2,7 +2,7 @@ module Foobara
   module BuiltinTypes
     module Entity
       module Validators
-        class AttributesDeclaration < DetachedEntity::Validators::AttributesDeclaration
+        class ModelInstanceIsValid < DetachedEntity::Validators::ModelInstanceIsValid
           def applicable?(record)
             record.created? || record.built?
           end

data/projects/model/src/concerns/reflection.rb

@@ -5,20 +5,26 @@ module Foobara
         include Concern
 
         module ClassMethods
-          def foobara_manifest(to_include: Set.new, remove_sensitive: false)
+          def foobara_manifest
+            remove_sensitive = TypeDeclarations.foobara_manifest_context_remove_sensitive?
+
             attributes_declaration = foobara_attributes_type.declaration_data
 
             if remove_sensitive
               attributes_declaration = TypeDeclarations.remove_sensitive_types(attributes_declaration)
             end
 
+            # TODO: do we really need all this stuff? Can't it be grabbed off of the declaration data to save
+            # space?
             Util.remove_blank(
               attributes_type: attributes_declaration,
               organization_name: foobara_type.foobara_domain.foobara_organization_name,
               domain_name: foobara_type.foobara_domain.foobara_domain_name,
               model_name: foobara_model_name,
               model_base_class: foobara_type.declaration_data[:model_base_class],
-              model_class: foobara_type.declaration_data[:model_class]
+              model_class: foobara_type.declaration_data[:model_class],
+              delegates:,
+              private: private_attribute_names
             )
           end
         end