foobara 0.0.1

data/projects/model/src/extensions/builtin_types/model/transformers/mutable.rb

@@ -0,0 +1,26 @@
+module Foobara
+  module BuiltinTypes
+    module Model
+      # TODO: Create Mutations/SupportedMutations concept
+      class Transformers
+        class Mutable < TypeDeclarations::Transformer
+          class << self
+            def requires_parent_declaration_data?
+              true
+            end
+          end
+
+          def transform(record)
+            record.mutable = if parent_declaration_data.key?(:mutable)
+                               parent_declaration_data[:mutable]
+                             else
+                               false
+                             end
+
+            record
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Foobara
+  module BuiltinTypes
+    module Model
+      module Validators
+        class AttributesDeclaration < TypeDeclarations::Processor
+          class << self
+            def requires_parent_declaration_data?
+              true
+            end
+          end
+
+          def always_applicable?
+            true
+          end
+
+          def process_value(model_instance)
+            Outcome.new(result: model_instance, errors: model_instance.validation_errors)
+          end
+
+          def possible_errors
+            model_class_name = parent_declaration_data[:model_class]
+
+            if model_class_name
+              Object.const_get(model_class_name).possible_errors
+            else
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendModelTypeDeclaration < ExtendRegisteredTypeDeclaration
+        class AttributesHandlerDesugarizer < TypeDeclarations::Desugarizer
+          def applicable?(sugary_type_declaration)
+            sugary_type_declaration[:type] == expected_type_symbol
+          end
+
+          def expected_type_symbol
+            :model
+          end
+
+          def desugarize(sugary_type_declaration)
+            handler = handler_for_class(ExtendAttributesTypeDeclaration)
+            attributes_type_declaration = sugary_type_declaration[:attributes_declaration]
+
+            sugary_type_declaration.merge(attributes_declaration: handler.desugarize(attributes_type_declaration))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      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)
+
+            sugary_type_declaration[:type] == expected_type_symbol
+          end
+
+          def expected_type_symbol
+            :model
+          end
+
+          def desugarize(sugary_type_declaration)
+            Util.symbolize_keys(sugary_type_declaration)
+          end
+
+          def priority
+            Priority::HIGH
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,119 @@
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendModelTypeDeclaration < ExtendRegisteredTypeDeclaration
+        class ModelClassDesugarizer < TypeDeclarations::Desugarizer
+          def applicable?(sugary_type_declaration)
+            sugary_type_declaration[:type] == expected_type_symbol
+          end
+
+          def expected_type_symbol
+            :model
+          end
+
+          def default_model_base_class
+            Foobara::Model
+          end
+
+          def desugarize(strictish_type_declaration)
+            klass = strictish_type_declaration[:model_class]
+
+            model_module = if strictish_type_declaration.key?(:model_module)
+                             mod = strictish_type_declaration[:model_module]
+
+                             mod = case mod
+                                   when ::Module
+                                     mod
+                                   when ::String, ::Symbol
+                                     Object.const_get(mod)
+                                   else
+                                     # :nocov:
+                                     raise ArgumentError,
+                                           "expected module_module to be a module or module name"
+                                     # :nocov:
+                                   end
+
+                             if mod == GlobalDomain
+                               Object
+                             else
+                               mod
+                             end
+                           else
+                             Object
+                           end
+
+            model_class = if klass.is_a?(::Class)
+                            klass
+                          elsif klass && Object.const_defined?(klass) && Object.const_get(klass).is_a?(::Class)
+                            Object.const_get(klass)
+                          else
+                            model_base_class = strictish_type_declaration[:model_base_class] || default_model_base_class
+
+                            if model_base_class.is_a?(::String) || model_base_class.is_a?(::Symbol)
+                              model_base_class = Object.const_get(model_base_class)
+                            end
+
+                            # TODO: why not call this domain_module instead????
+
+                            model_name = strictish_type_declaration[:name]
+
+                            existing_class = if model_module.const_defined?(model_name)
+                                               model_module.const_get(model_name)
+                                             end
+
+                            # TODO: This is a pretty crazy situation and hacky. Should come up with a better solution.
+                            # Here's the situation: if models are nested, like A::B and A and A::B are modules, then
+                            # if A::B is imported first, A will be created as a module via make_module_p.
+                            # But then when we are here creating A, A is already in use incorrectly as a module.
+                            # We need to move A out of the way but set all of its constants on the newly created model
+                            # A.
+                            if existing_class.is_a?(::Module) && !existing_class.is_a?(::Class)
+                              if existing_class.instance_variable_get(
+                                :@foobara_created_via_make_class
+                              )
+                                existing_module_to_copy_over = existing_class
+                                parent_mod = Util.module_for(existing_class)
+                                parent_mod.send(:remove_const, Util.non_full_name(existing_class))
+                                existing_class = nil
+                              end
+                            end
+
+                            # TODO: feels too destructive to be in a desugarizer. Technically probably should be in the
+                            # to type transformer instead.
+                            existing_class || model_base_class.subclass(
+                              **create_model_class_args(model_module:, type_declaration: strictish_type_declaration)
+                            ).tap do |model_class|
+                              if existing_module_to_copy_over
+                                Foobara::Domain::DomainModuleExtension._copy_constants(
+                                  existing_module_to_copy_over, model_class
+                                )
+                              end
+                            end
+                          end
+
+            strictish_type_declaration[:model_class] = model_class.name
+            model_module ||= Util.module_for(model_class)
+
+            model_module = nil if model_module == Object
+
+            strictish_type_declaration[:model_module] = model_module&.name
+            strictish_type_declaration[:model_base_class] = model_class.superclass.name
+
+            strictish_type_declaration
+          end
+
+          def create_model_class_args(model_module:, type_declaration:)
+            {
+              name: type_declaration[:name],
+              model_module:
+            }
+          end
+
+          def priority
+            Priority::LOW
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendModelTypeDeclaration < ExtendRegisteredTypeDeclaration
+        class ToTypeTransformer < ExtendRegisteredTypeDeclaration::ToTypeTransformer
+          # TODO: make declaration validator for model_class and model_base_class
+          def target_classes(strict_type_declaration)
+            Object.const_get(strict_type_declaration[:model_class])
+          end
+
+          # TODO: must explode if name missing...
+          def type_name(strict_type_declaration)
+            strict_type_declaration[:name]
+          end
+
+          # TODO: create declaration validator for name and the others
+          # TODO: seems like a smell that we don't have processors for these?
+          def non_processor_keys
+            [:name, :model_class, :model_base_class, :model_module, :attributes_declaration, :mutable, *super]
+          end
+
+          def process_value(...)
+            super.tap do |outcome|
+              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)
+
+                model_class = type.target_class
+                existing_model_type = model_class.model_type
+
+                domain = model_class.domain || Domain.global
+
+                if existing_model_type
+                  if existing_model_type.declaration_data != type.declaration_data &&
+                     domain.foobara_type_registered?(existing_model_type)
+                    type.type_symbol = type.declaration_data[:name]
+                    model_class.model_type = type
+                    domain.foobara_reregister_model(model_class)
+                  end
+                else
+                  model_class.model_type = type
+                  type.type_symbol = type.declaration_data[:name]
+                  model_class.description type.declaration_data[:description]
+                  domain.foobara_register_model(model_class)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Foobara
+  module TypeDeclarations
+    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
+          end
+        end
+
+        def expected_type_symbol
+          :model
+        end
+
+        def priority
+          Priority::LOW
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendRegisteredModelTypeDeclaration < ExtendRegisteredTypeDeclaration
+        class HashDesugarizer < TypeDeclarations::Desugarizer
+          def applicable?(sugary_type_declaration)
+            return false unless sugary_type_declaration.is_a?(::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
+                )
+
+                type&.extends?(BuiltinTypes[expected_type_symbol])
+              end
+            end
+          end
+
+          def expected_type_symbol
+            :model
+          end
+
+          def desugarize(sugary_type_declaration)
+            Util.symbolize_keys(sugary_type_declaration)
+          end
+
+          def priority
+            Priority::HIGH
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendRegisteredModelTypeDeclaration < ExtendRegisteredTypeDeclaration
+        class ModelClassTypeDesugarizer < TypeDeclarations::Desugarizer
+          def applicable?(sugary_type_declaration)
+            if sugary_type_declaration.is_a?(::Hash) && sugary_type_declaration.key?(:type)
+              type = sugary_type_declaration[:type]
+              type.is_a?(::Class) && type < Model
+            end
+          end
+
+          def desugarize(hash)
+            model_class = hash[:type]
+            hash.merge(type: model_class.model_type.foobara_manifest_reference.to_sym)
+          end
+
+          def priority
+            Priority::FIRST
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendRegisteredModelTypeDeclaration < ExtendRegisteredTypeDeclaration
+        class MutableValidator < TypeDeclarations::TypeDeclarationValidator
+          class InvalidMutableValueGivenError < Value::DataError
+            class << self
+              def context_type_declaration
+                {
+                  invalid_key: :symbol,
+                  valid_attribute_names: [:symbol],
+                  mutable: [:symbol]
+                }
+              end
+            end
+          end
+
+          def applicable?(value)
+            value.key?(:mutable)
+          end
+
+          def validation_errors(strict_type_declaration)
+            mutable = strict_type_declaration[:mutable]
+            return if [true, false].include?(mutable)
+
+            model_type = type_for_declaration(strict_type_declaration[:type])
+            valid_attribute_names = model_type.element_types.element_types.keys
+
+            mutable.map do |key|
+              unless valid_attribute_names.include?(key)
+                build_error(
+                  message: "#{key} is not a valid attribute, expected one of #{valid_attribute_names}",
+                  context: {
+                    invalid_key: key,
+                    valid_attribute_names:,
+                    mutable:
+                  }
+                )
+              end
+            end.compact
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendRegisteredModelTypeDeclaration < ExtendRegisteredTypeDeclaration
+        class NormalizeMutableAttributesDesugarizer < TypeDeclarations::Desugarizer
+          def applicable?(value)
+            if value.is_a?(::Hash) && value.key?(:mutable) && value.key?(:type)
+              mutable = value[:mutable]
+
+              return false if [true, false].include?(mutable)
+
+              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])
+              end
+            end
+          end
+
+          def desugarize(rawish_type_declaration)
+            rawish_type_declaration.merge(
+              mutable: Util.array(rawish_type_declaration[:mutable]).map!(&:to_sym)
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendRegisteredModelTypeDeclaration < ExtendRegisteredTypeDeclaration
+        class ToTypeTransformer < ExtendRegisteredTypeDeclaration::ToTypeTransformer
+          # TODO: make declaration validator for model_class and model_base_class
+          def target_classes(strict_type_declaration)
+            declaration_to_type(strict_type_declaration).target_classes
+          end
+
+          # TODO: must explode if name missing...
+          def type_name(strict_type_declaration)
+            declaration_to_type(strict_type_declaration).name
+          end
+
+          def declaration_to_type(strict_type_declaration)
+            type_for_declaration(strict_type_declaration[:type])
+          end
+
+          def non_processor_keys
+            [:mutable, *super]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      # Why doesn't this inherit from ExtendModelTypeDeclaration
+      class ExtendRegisteredModelTypeDeclaration < ExtendRegisteredTypeDeclaration
+        def applicable?(sugary_type_declaration)
+          strict_type_declaration = desugarize(sugary_type_declaration)
+
+          if strict_type_declaration.is_a?(::Hash) && strict_type_declaration.key?(:type)
+            type_symbol = strict_type_declaration[:type]
+
+            return false if type_symbol == expected_type_symbol
+
+            if type_registered?(type_symbol)
+              type = type_for_declaration(type_symbol)
+              type.extends?(BuiltinTypes[expected_type_symbol])
+            end
+          end
+        end
+
+        def expected_type_symbol
+          :model
+        end
+
+        def priority
+          super - 1
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class RegisteredTypeDeclaration < TypeDeclarationHandler
+        class ModelClassDesugarizer < TypeDeclarations::Desugarizer
+          def applicable?(sugary_type_declaration)
+            sugary_type_declaration.is_a?(Class) && sugary_type_declaration < Model
+          end
+
+          def desugarize(model_class)
+            {
+              type: model_class.model_type.foobara_manifest_reference.to_sym
+            }
+          end
+
+          def priority
+            Priority::FIRST - 1
+          end
+        end
+      end
+    end
+  end
+end