foobara 0.0.142 → 0.1.1

data/projects/detached_entity/src/extensions/type_declarations/handlers/extend_detached_entity_type_declaration/hash_desugarizer.rb

@@ -4,10 +4,8 @@ module Foobara
       class ExtendDetachedEntityTypeDeclaration < ExtendModelTypeDeclaration
         class HashDesugarizer < TypeDeclarations::Desugarizer
           def applicable?(sugary_type_declaration)
-            return false unless sugary_type_declaration.is_a?(::Hash)
-            return false unless Util.all_symbolizable_keys?(sugary_type_declaration)
-
-            sugary_type_declaration = Util.symbolize_keys(sugary_type_declaration)
+            return false unless sugary_type_declaration.hash?
+            return false unless sugary_type_declaration.all_symbolizable_keys?
 
             type_symbol = sugary_type_declaration[:type] || sugary_type_declaration["type"]
             return false unless type_symbol
@@ -16,10 +14,9 @@ module Foobara
 
             return true if type_symbol == expected_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)
+              type = sugary_type_declaration.type ||
+                     lookup_type(type_symbol, mode: Namespace::LookupMode::ABSOLUTE)
 
               type&.extends?(BuiltinTypes[expected_type_symbol])
             end
@@ -30,7 +27,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/detached_entity/src/extensions/type_declarations/handlers/extend_detached_entity_type_declaration/primary_key_desugarizer.rb

@@ -10,7 +10,8 @@ module Foobara
           end
 
           def desugarize(sugary_type_declaration)
-            sugary_type_declaration.merge(primary_key: sugary_type_declaration[:primary_key].to_sym)
+            sugary_type_declaration[:primary_key] = sugary_type_declaration[:primary_key].to_sym
+            sugary_type_declaration
           end
         end
       end

data/projects/domain/src/domain_module_extension.rb

@@ -316,7 +316,10 @@ module Foobara
           # TODO: introduce a Namespace#scope method to simplify this a bit
           Foobara::Namespace.use self do
             if block
-              args = [TypeDeclarations::Dsl::Attributes.to_declaration(&block), *args]
+              args = [
+                TypeDeclarations::Dsl::Attributes.to_declaration(&block).declaration_data,
+                *args
+              ]
             end
 
             attributes_type_declaration, *args = args
@@ -358,7 +361,7 @@ module Foobara
                              scoped_full_name
                            end
 
-            entity_type = foobara_type_builder.type_for_declaration(
+            declaration = TypeDeclaration.new(
               Util.remove_blank(
                 type: :entity,
                 name:,
@@ -366,11 +369,15 @@ module Foobara
                 model_module:,
                 attributes_declaration: attributes_type_declaration,
                 primary_key:,
-                description:,
-                _desugarized: { type_absolutified: true }
+                description:
               )
             )
 
+            declaration.is_absolutified = true
+            declaration.is_duped = true
+
+            entity_type = foobara_type_builder.type_for_declaration(declaration)
+
             entity_type.target_class
           end
         end
@@ -428,6 +435,7 @@ module Foobara
             foobara_depends_on_namespaces << domain
             foobara_type_builder.accesses << domain.foobara_type_builder
 
+            lru_cache.reset!
             foobara_depends_on << domain_name
           end
         end

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

@@ -6,7 +6,12 @@ module Foobara
 
         module ClassMethods
           def type_declaration(...)
-            super.merge(type: :entity)
+            declaration = super
+
+            declaration[:type] = :entity
+            declaration.is_absolutified = true
+
+            declaration
           end
         end
       end

data/projects/foobara/lib/foobara/all.rb

@@ -34,13 +34,13 @@ module Foobara
            "model",
            "detached_entity",
            "entity",
-           "model_attribute_helpers",
+           "persistence",
            "nested_transactionable",
-           "command",
-           "domain_mapper",
-           "persistence", # Feels like this would be loaded before command?
+           "model_attribute_helpers",
            "in_memory_crud_driver_minimal",
            "in_memory_crud_driver",
+           "command",
+           "domain_mapper",
            "manifest"
 
   install!

data/projects/manifest/src/foobara/manifest/type.rb

@@ -70,13 +70,22 @@ module Foobara
         scoped_full_name
       end
 
+      # TODO: replace this with primitive?
       def builtin?
         BuiltinTypes.builtin_reference?(reference)
       end
 
-      # Not sure the best way to define this...
+      def primitive?
+        declaration_data.is_a?(::String) || declaration_data.is_a?(::Symbol)
+      end
+
+      # This name is confusing.
+      # This represents a type that is 1) registered 2) not primitive 3) does not inherit from :model
+      # Because this is a Manifest::Type it is registered by definition. Non-registered types are
+      # represented in the manifest only as type declarations scattered the other categories where
+      # needed.
       def custom?
-        !builtin? && !model?
+        !primitive? && !extends_symbol?(:model)
       end
 
       def extends_symbol?(symbol)

data/projects/manifest/src/foobara/manifest/type_declaration.rb

@@ -90,6 +90,12 @@ module Foobara
         @custom = to_type.custom?
       end
 
+      def primitive?
+        if reference?
+          to_type.primitive?
+        end
+      end
+
       def to_model
         raise "not an model" unless model?
 
@@ -108,7 +114,12 @@ module Foobara
 
       def to_detached_entity
         raise "not an detached_entity" unless detached_entity?
-        raise "detached_entity extension instead of an detached_entity" unless relevant_manifest.size == 1
+
+        if to_type.primitive?
+          # :nocov:
+          raise "detached_entity extension instead of an detached_entity"
+          # :nocov:
+        end
 
         type = to_type
 
@@ -125,7 +136,12 @@ module Foobara
 
       def to_entity
         raise "not an entity" unless entity?
-        raise "entity extension instead of an entity" unless relevant_manifest.size == 1
+
+        if to_type.primitive?
+          # :nocov:
+          raise "entity extension instead of an entity"
+          # :nocov:
+        end
 
         type = to_type
 
@@ -138,6 +154,34 @@ module Foobara
         # awkward??
         @to_type ||= find_type(self)
       end
+
+      def type
+        if reference?
+          relevant_manifest
+        else
+          super
+        end
+      end
+
+      def sensitive
+        if reference?
+          false
+        else
+          super
+        end
+      end
+
+      def sensitive_exposed
+        if reference?
+          false
+        else
+          super
+        end
+      end
+
+      def reference?
+        relevant_manifest.is_a?(::Symbol) || relevant_manifest.is_a?(::String)
+      end
     end
   end
 end

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

@@ -8,6 +8,14 @@ module Foobara
           def model_name(...)
             foobara_model_name(...)
           end
+
+          def delegates(...)
+            foobara_delegates(...)
+          end
+
+          def private_attribute_names
+            foobara_private_attribute_names
+          end
         end
       end
     end

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

@@ -23,8 +23,8 @@ module Foobara
               model_name: foobara_model_name,
               model_base_class: foobara_type.declaration_data[:model_base_class],
               model_class: foobara_type.declaration_data[:model_class],
-              delegates:,
-              private: private_attribute_names
+              delegates: foobara_delegates,
+              private: foobara_private_attribute_names
             )
           end
         end

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

@@ -63,9 +63,12 @@ module Foobara
               declaration = type_declaration(attributes_type.declaration_data)
 
               if model_type
-                unless Foobara::TypeDeclarations.declarations_equal?(declaration, model_type.declaration_data)
+                unless Foobara::TypeDeclarations.declarations_equal?(declaration.declaration_data,
+                                                                     model_type.declaration_data)
+
                   type_domain = domain
                   self.model_type = nil
+
                   type_domain.foobara_type_from_declaration(declaration)
                 end
               else
@@ -97,19 +100,25 @@ module Foobara
               end
             end
 
-            Util.remove_blank(
-              type: :model,
-              name: model_name,
-              model_module: model_module_name,
-              model_class:,
-              model_base_class:,
-              attributes_declaration:,
-              description:,
-              _desugarized: { type_absolutified: true },
-              mutable:,
-              delegates:,
-              private: private_attribute_names
+            type_declaration = TypeDeclaration.new(
+              Util.remove_blank(
+                type: :model,
+                name: model_name,
+                model_module: model_module_name,
+                model_class:,
+                model_base_class:,
+                attributes_declaration:,
+                description:,
+                mutable:,
+                delegates:,
+                private: private_attribute_names
+              )
             )
+
+            type_declaration.is_absolutified = true
+            type_declaration.is_duped = true
+
+            type_declaration
           end
 
           def foobara_attributes_type
@@ -152,16 +161,16 @@ module Foobara
             end
           end
 
-          def delegates
-            @delegates ||= {}
+          def foobara_delegates
+            @foobara_delegates ||= {}
           end
 
           def has_delegated_attributes?
             !delegates.empty?
           end
 
-          def private_attribute_names
-            @private_attribute_names ||= []
+          def foobara_private_attribute_names
+            @foobara_private_attribute_names ||= []
           end
 
           def private_attributes(attribute_names)
@@ -171,7 +180,7 @@ module Foobara
           end
 
           def private_attribute(attribute_name)
-            @private_attribute_names = private_attribute_names | [attribute_name]
+            @foobara_private_attribute_names = private_attribute_names | [attribute_name]
 
             set_model_type
           end
@@ -229,20 +238,26 @@ module Foobara
             private = []
             attributes_type_declaration = TypeDeclarations.args_to_type_declaration(...)
 
-            if attributes_type_declaration.is_a?(::Hash) || attributes_type_declaration.is_a?(Proc)
+            if attributes_type_declaration.hash? || attributes_type_declaration.proc?
               handler = domain.foobara_type_builder.handler_for_class(
                 TypeDeclarations::Handlers::ExtendAttributesTypeDeclaration
               )
               attributes_type_declaration = Namespace.use domain do
-                handler.desugarize(attributes_type_declaration)
+                handler.desugarize(attributes_type_declaration.clone)
               end
 
               element_type_declarations = attributes_type_declaration[:element_type_declarations]
 
               element_type_declarations.each_pair do |attribute_name, attribute_type_declaration|
+                next if attribute_type_declaration.is_a?(::Symbol)
+
                 is_private = attribute_type_declaration.delete(:private)
 
                 if is_private
+                  if attribute_type_declaration.keys.size == 1
+                    element_type_declarations[attribute_name] = attribute_type_declaration[:type]
+                  end
+
                   private |= [attribute_name]
                 end
               end

data/projects/model/src/extensions/builtin_types/model/validators/model_instance_is_valid.rb

@@ -22,16 +22,20 @@ module Foobara
           end
 
           def possible_errors
-            model_class_name = parent_declaration_data[:model_class]
+            if parent_declaration_data.is_a?(::Hash)
+              model_class_name = parent_declaration_data[:model_class]
 
-            if model_class_name
-              model_class = if Object.const_defined?(model_class_name)
-                              Object.const_get(model_class_name)
-                            else
-                              Namespace.current.foobara_lookup_type!(model_class_name).target_class
-                            end
+              if model_class_name
+                model_class = if Object.const_defined?(model_class_name)
+                                Object.const_get(model_class_name)
+                              else
+                                Namespace.current.foobara_lookup_type!(model_class_name).target_class
+                              end
 
-              model_class.possible_errors
+                model_class.possible_errors
+              else
+                super
+              end
             else
               super
             end

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

@@ -12,7 +12,7 @@ module Foobara
           end
 
           def applicable?(strict_type_declaration)
-            strict_type_declaration.is_a?(Hash) && strict_type_declaration.key?(:private)
+            strict_type_declaration.hash? && strict_type_declaration.key?(:private)
           end
 
           def validation_errors(strict_type_declaration)

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

@@ -15,7 +15,21 @@ module Foobara
             handler = handler_for_class(ExtendAttributesTypeDeclaration)
             attributes_type_declaration = sugary_type_declaration[:attributes_declaration]
 
-            sugary_type_declaration.merge(attributes_declaration: handler.desugarize(attributes_type_declaration))
+            declaration = sugary_type_declaration.clone_from_part(attributes_type_declaration)
+
+            if sugary_type_declaration.deep_duped?
+              # TODO: probably not worth directly testing this path
+              # :nocov:
+              declaration.is_duped = true
+              declaration.is_deep_duped = true
+              # :nocov:
+            end
+
+            declaration = handler.desugarize(declaration)
+
+            sugary_type_declaration[:attributes_declaration] = declaration.declaration_data
+
+            sugary_type_declaration
           end
         end
       end

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

@@ -8,13 +8,13 @@ module Foobara
           end
 
           def desugarize(sugary_type_declaration)
-            desugarized = sugary_type_declaration.dup
-            delegates = Util.deep_symbolize_keys(desugarized[:delegates])
+            delegates = sugary_type_declaration[:delegates]
 
             if delegates.empty?
-              desugarized.delete(:delegates)
-              desugarized
+              sugary_type_declaration.delete(:delegates)
             else
+              delegates = Util.deep_symbolize_keys(sugary_type_declaration[:delegates])
+
               delegates.each_pair do |attribute_name, delegate_info|
                 h = delegate_info.merge(data_path: DataPath.new(delegate_info[:data_path]).to_s)
 
@@ -29,8 +29,10 @@ module Foobara
                 delegates[attribute_name] = h
               end
 
-              sugary_type_declaration.merge(delegates:)
+              sugary_type_declaration[:delegates] = delegates
             end
+
+            sugary_type_declaration
           end
         end
       end

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

@@ -4,12 +4,8 @@ module Foobara
       class ExtendModelTypeDeclaration < ExtendRegisteredTypeDeclaration
         class HashDesugarizer < TypeDeclarations::Desugarizer
           def applicable?(sugary_type_declaration)
-            return false unless sugary_type_declaration.is_a?(::Hash)
-            return false unless Util.all_symbolizable_keys?(sugary_type_declaration)
-
-            sugary_type_declaration = Util.symbolize_keys(sugary_type_declaration)
-
-            return true unless sugary_type_declaration.key?(:type)
+            return false unless sugary_type_declaration.hash?
+            return false unless sugary_type_declaration.all_symbolizable_keys?
 
             sugary_type_declaration[:type] == expected_type_symbol
           end
@@ -19,7 +15,8 @@ module Foobara
           end
 
           def desugarize(sugary_type_declaration)
-            Util.symbolize_keys(sugary_type_declaration)
+            sugary_type_declaration.symbolize_keys!
+            sugary_type_declaration
           end
 
           def priority

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

@@ -17,8 +17,6 @@ module Foobara
 
           # TODO: consider splitting this up into multiple desugarizers
           def desugarize(strictish_type_declaration)
-            strictish_type_declaration = strictish_type_declaration.dup
-
             if strictish_type_declaration.key?(:model_module)
               model_module = strictish_type_declaration[:model_module]
 

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

@@ -4,19 +4,28 @@ module Foobara
       class ExtendModelTypeDeclaration < ExtendRegisteredTypeDeclaration
         class MovePrivateFromElementTypesToRoot < TypeDeclarations::Desugarizer
           def applicable?(value)
-            if value.is_a?(::Hash) && value.key?(:type) && value.key?(:attributes_declaration)
-              type_symbol = value[:type]
+            if value.hash? && value.key?(:type) && value.key?(:attributes_declaration)
+              type = value.type || lookup_type(value[:type])
 
-              if type_registered?(type_symbol)
-                type = lookup_type!(type_symbol)
-                type.extends?(BuiltinTypes[:model])
+              if type
+                if type.extends?(BuiltinTypes[:model])
+                  value.base_type = type
+                  true
+                end
               end
             end
           end
 
           def desugarize(rawish_type_declaration)
             private = rawish_type_declaration[:private]
-            private = private ? private.dup : []
+
+            if private.nil?
+              private = []
+            else
+              unless rawish_type_declaration.deep_duped?
+                private = private.dup
+              end
+            end
 
             attributes_declaration = rawish_type_declaration[:attributes_declaration]
             element_type_declarations = attributes_declaration[:element_type_declarations]
@@ -24,7 +33,15 @@ module Foobara
             element_type_declarations.each_pair do |attribute_name, attribute_type_declaration|
               if attribute_type_declaration.is_a?(Hash) && attribute_type_declaration.key?(:private)
                 is_private = attribute_type_declaration[:private]
-                element_type_declarations[attribute_name] = attribute_type_declaration.except(:private)
+
+                declaration = attribute_type_declaration.except(:private)
+
+                if declaration.keys == [:type]
+                  declaration = TypeDeclaration.new(declaration).declaration_data
+                end
+
+                element_type_declarations[attribute_name] = declaration
+
                 if is_private
                   private |= [attribute_name]
                 end
@@ -32,10 +49,12 @@ module Foobara
             end
 
             if private.empty?
-              rawish_type_declaration.except(:private)
+              rawish_type_declaration.delete(:private)
             else
-              rawish_type_declaration.merge(private:)
+              rawish_type_declaration[:private] = private
             end
+
+            rawish_type_declaration
           end
 
           def priority

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

@@ -4,11 +4,12 @@ module Foobara
       class ExtendModelTypeDeclaration < ExtendRegisteredTypeDeclaration
         class SymbolizePrivate < TypeDeclarations::Desugarizer
           def applicable?(value)
-            if value.is_a?(::Hash) && value.key?(:type) && value.key?(:attributes_declaration) && value.key?(:private)
-              type_symbol = value[:type]
+            if value.hash? && value.key?(:type) && value.key?(:attributes_declaration) && value.key?(:private)
 
-              if type_registered?(type_symbol)
-                type = lookup_type!(type_symbol)
+              type = value.type || lookup_type(value[:type])
+
+              if type
+                value.type = type
                 type.extends?(BuiltinTypes[:model])
               end
             end
@@ -18,10 +19,10 @@ module Foobara
             private = rawish_type_declaration[:private]
 
             if private.any? { |key| key.is_a?(::String) }
-              rawish_type_declaration.merge(private: private.map(&:to_sym))
-            else
-              rawish_type_declaration
+              rawish_type_declaration[:private] = private.map(&:to_sym)
             end
+
+            rawish_type_declaration
           end
 
           def priority

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

@@ -25,7 +25,7 @@ module Foobara
             else
               existing_type = Domain.current.foobara_lookup_type(
                 model_class_name,
-                mode: Namespace::LookupMode::ABSOLUTE
+                mode: Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE
               )
 
               existing_type&.target_class
@@ -77,10 +77,7 @@ module Foobara
               if outcome.success?
                 type = outcome.result
 
-                handler = handler_for_class(ExtendAttributesTypeDeclaration)
-                attributes_type_declaration = type.declaration_data[:attributes_declaration]
-
-                type.element_types = handler.process_value!(attributes_type_declaration)
+                type.element_types = :Model
 
                 model_class = type.target_class
                 existing_model_type = model_class.model_type
@@ -105,8 +102,8 @@ module Foobara
 
                   model_class.description type.declaration_data[:description]
 
-                  if domain.foobara_type_registered?(type_symbol, mode: Namespace::LookupMode::ABSOLUTE)
-                    existing_type = domain.foobara_lookup_type(type_symbol, mode: Namespace::LookupMode::ABSOLUTE)
+                  if domain.foobara_type_registered?(type_symbol, mode: Namespace::LookupMode::DIRECT)
+                    existing_type = domain.foobara_lookup_type(type_symbol, mode: Namespace::LookupMode::DIRECT)
                     domain.foobara_unregister(existing_type)
                   end
 

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

@@ -3,8 +3,20 @@ module Foobara
     module Handlers
       class ExtendModelTypeDeclaration < ExtendRegisteredTypeDeclaration
         def applicable?(sugary_type_declaration)
-          if sugary_type_declaration.is_a?(::Hash)
-            desugarize(sugary_type_declaration)[:type] == expected_type_symbol
+          if sugary_type_declaration.hash?
+            strict_type_declaration = if sugary_type_declaration.strict?
+                                        sugary_type_declaration
+                                      else
+                                        desugarize(sugary_type_declaration.clone)
+                                      end
+
+            if strict_type_declaration[:type] == expected_type_symbol
+              unless sugary_type_declaration.equal?(strict_type_declaration)
+                sugary_type_declaration.assign(strict_type_declaration)
+              end
+
+              true
+            end
           end
         end