foobara 0.0.142 → 0.1.2

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
 

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