foobara 0.0.80 → 0.0.81

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b2fdc64452fe8ed0285ac3b9d9ad26108cd7157f798a3fac36b814a0855d802
-  data.tar.gz: 4e37ca0d5af8ffd919b068a2fb67573ecddf056e2b13d6d39604f09188cc11c6
+  metadata.gz: 66f1d5b1015809a2646a0627b8d6af04bdca39257a21a361e5cb78807b0ba611
+  data.tar.gz: 565397a74e404cdba4e629d2bb28b27dcb5b23f2e144a8dfeccac22690600a45
 SHA512:
-  metadata.gz: cefd96fe33a1c2fdf1fd2f53aa128e8c6f636507d921f0f30dd9730983b8fa10c5aa10b43bd2b8c0008f50452106f90cf7b8bacae9b0142df4898d3c1ba62b2f
-  data.tar.gz: b8fb560d295f3fe8c6a1f0e194f8528a02771e5504b9c482235e16cd9cba7cb0d51858e7b12952027e14d78909a4fd07c68be54553ff3b6356f029ff4cc3259c
+  metadata.gz: 42b0474e8712dfc36495379cd12d61b7c6aee754382cce807a330038d5fd249ebfe3bc4f7b503d0a1d80b92c12b67ab1297007d3535e9983e9ae1a116e8bd31b
+  data.tar.gz: a12f6239df09e306ee8a1587f56e74cce4d9bfc78393daeb648b82c91f0d07806ba8e5ebec48b80f4f77e4e956e82667d7b95b0448367a7b5c1ae4d862380a3a

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+# [0.0.81] - 2025-03-21
+
+- No longer automatically creates Foobara::Model classes when creating a foobara model type via type declaration
+
 # [0.0.80] - 2025-03-19
 
 - Fix bug preventing combining array type sugar with sensitive flag in type declarations

data/projects/detached_entity/src/detached_entity.rb

@@ -7,11 +7,5 @@ module Foobara
     include Concerns::Types
     include Concerns::Aliases
     include Concerns::Serialize
-
-    class << self
-      def allowed_subclass_opts
-        [:primary_key, *super]
-      end
-    end
   end
 end

data/projects/detached_entity/src/extensions/builtin_types/detached_entity/casters/hash.rb

@@ -2,35 +2,19 @@ module Foobara
   module BuiltinTypes
     module DetachedEntity
       module Casters
-        class Hash < Attributes::Casters::Hash
+        class Hash < BuiltinTypes::Model::Casters::Hash
           class << self
             def requires_parent_declaration_data?
               true
             end
           end
 
-          def cast(attributes)
-            symbolized_attributes = super
-
-            entity_class.send(build_method(symbolized_attributes), symbolized_attributes)
-          end
-
-          def build_method(_symbolized_attributes)
-            :new
+          def expected_type_symbol
+            :detached_entity
           end
 
           def entity_class
-            type = parent_declaration_data[:type]
-
-            if type == expected_type_symbol
-              Object.const_get(parent_declaration_data[:model_class])
-            else
-              Foobara::Namespace.current.foobara_lookup_type!(type).target_class
-            end
-          end
-
-          def expected_type_symbol
-            :detached_entity
+            model_class
           end
         end
       end

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

@@ -15,7 +15,13 @@ module Foobara
 
           def entity_class
             if parent_declaration_data.key?(:model_class)
-              Object.const_get(parent_declaration_data[:model_class])
+              model_class_name = parent_declaration_data[:model_class]
+
+              if Object.const_defined?(model_class_name)
+                Object.const_get(parent_declaration_data[:model_class])
+              else
+                Namespace.current.foobara_lookup_type!(model_class_name).target_class
+              end
             elsif parent_declaration_data[:type] != expected_type_symbol
               model_type = type_for_declaration(parent_declaration_data[:type])
               model_type.target_class

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

@@ -10,10 +10,6 @@ module Foobara
           def default_model_base_class
             Foobara::DetachedEntity
           end
-
-          def create_model_class_args(model_module:, type_declaration:)
-            super.merge(primary_key: type_declaration[:primary_key])
-          end
         end
       end
     end

data/projects/domain/src/domain_module_extension.rb

@@ -281,7 +281,14 @@ module Foobara
         def foobara_register_model(model_class)
           type = model_class.model_type
 
-          if type.scoped_path_set? && foobara_registered?(type.scoped_full_name, mode: Namespace::LookupMode::DIRECT)
+          full_name = type.scoped_full_name
+
+          if model_class.full_model_name.size > full_name.size
+            # TODO: why does this happen exactly??
+            full_name = model_class.full_model_name
+          end
+
+          if type.scoped_path_set? && foobara_registered?(full_name, mode: Namespace::LookupMode::DIRECT)
             # :nocov:
             raise AlreadyRegisteredError, "Already registered: #{type.inspect}"
             # :nocov:
@@ -293,6 +300,11 @@ module Foobara
           type.target_class
         end
 
+        def foobara_register_and_deanonymize_entity(name, *, &)
+          entity_class = foobara_register_entity(name, *, &)
+          Foobara::Model.deanonymize_class(entity_class)
+        end
+
         # TODO: kill this off
         def foobara_register_entity(name, *args, &block)
           # TODO: introduce a Namespace#scope method to simplify this a bit
@@ -336,27 +348,41 @@ module Foobara
             # TODO: reuse the model_base_class primary key if it has one...
             primary_key = attributes_type.element_types.keys.first
 
-            foobara_type_builder.type_for_declaration(
+            entity_type = foobara_type_builder.type_for_declaration(
               Util.remove_blank(
                 type: :entity,
                 name:,
                 model_base_class:,
-                attributes_declaration: attributes_type_declaration,
                 model_module: self,
+                attributes_declaration: attributes_type_declaration,
                 primary_key:,
                 description:,
                 _desugarized: { type_absolutified: true }
               )
-            ).target_class
+            )
+
+            entity_type.target_class
           end
         end
 
+        def foobara_register_and_deanonymize_entities(entity_names_to_attributes)
+          entities = []
+
+          entity_names_to_attributes.each_pair do |entity_name, attributes_declaration|
+            entities << foobara_register_and_deanonymize_entity(entity_name, attributes_declaration)
+          end
+
+          entities
+        end
+
         def foobara_register_entities(entity_names_to_attributes)
+          entities = []
+
           entity_names_to_attributes.each_pair do |entity_name, attributes_type_declaration|
-            foobara_register_entity(entity_name, attributes_type_declaration)
+            entities << foobara_register_entity(entity_name, attributes_type_declaration)
           end
 
-          nil
+          entities
         end
 
         def foobara_can_call_subcommands_from?(other_domain)

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

@@ -0,0 +1,75 @@
+module Foobara
+  class Model
+    module Concerns
+      module Classes
+        include Concern
+
+        module ClassMethods
+          def deanonymize_class(anonymous_model_class)
+            type_declaration = anonymous_model_class.model_type.declaration_data
+            model_module_name = type_declaration[:model_module]
+
+            model_module = if model_module_name
+                             if Object.const_defined?(model_module_name)
+                               Object.const_get(model_module_name)
+                             else
+                               Util.make_module_p(model_module_name)
+                             end
+                           end
+
+            if model_module == GlobalDomain || !model_module
+              model_module = Object
+            end
+
+            klass = type_declaration[:model_class]
+
+            if klass && Object.const_defined?(klass) && Object.const_get(klass).is_a?(::Class)
+              # should we raise an exception??
+              Object.const_get(klass)
+            else
+              model_name = 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))
+                else
+                  # :nocov:
+                  return existing_class
+                  # :nocov:
+                end
+              end
+
+              if existing_module_to_copy_over
+                Foobara::Domain::DomainModuleExtension._copy_constants(
+                  existing_module_to_copy_over, anonymous_model_class
+                )
+              end
+
+              if model_name.include?("::")
+                model_module_name = "#{model_module.name}::#{model_name.split("::")[..-2].join("::")}"
+                model_module = Util.make_module_p(model_module_name, tag: true)
+              end
+
+              const_name = model_name.split("::").last
+
+              model_module.const_set(const_name, anonymous_model_class)
+
+              anonymous_model_class
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -85,20 +85,30 @@ module Foobara
           end
 
           def type_declaration(attributes_declaration)
-            if name.start_with?(closest_namespace_module.name)
-              model_module_name = closest_namespace_module.name
-              model_name = name.gsub(/^#{closest_namespace_module.name}::/, "")
+            if name
+              model_base_class = superclass.name
+              model_class = name
+
+              if name.start_with?(closest_namespace_module.name)
+                model_module_name = closest_namespace_module.name
+                model_name = name.gsub(/^#{closest_namespace_module.name}::/, "")
+              else
+                model_module_name = nil
+                model_name = name
+              end
             else
-              model_module_name = nil
-              model_name = name
+              model_module_name = model_type.declaration_data[:model_module]
+              model_class = model_type.declaration_data[:model_class]
+              model_name = model_type.scoped_name
+              model_base_class = superclass.name || superclass.model_type.scoped_full_name
             end
 
             Util.remove_blank(
               type: :model,
               name: model_name,
               model_module: model_module_name,
-              model_class: name,
-              model_base_class: superclass.name,
+              model_class:,
+              model_base_class:,
               attributes_declaration:,
               description:,
               _desugarized: { type_absolutified: true },

data/projects/model/src/extensions/builtin_types/model/casters/hash.rb

@@ -10,18 +10,34 @@ module Foobara
           end
 
           def cast(attributes)
-            model_class.new(super)
+            symbolized_attributes = super
+
+            model_class.send(build_method(symbolized_attributes), symbolized_attributes)
           end
 
           def model_class
             type = parent_declaration_data[:type]
 
-            if type == :model
-              Object.const_get(parent_declaration_data[:model_class])
+            if type == expected_type_symbol
+              model_class_name = parent_declaration_data[:model_class]
+
+              if Object.const_defined?(model_class_name)
+                Object.const_get(parent_declaration_data[:model_class])
+              else
+                Namespace.current.foobara_lookup_type!(model_class_name).target_class
+              end
             else
-              Foobara::Namespace.current.foobara_lookup_type!(type).target_class
+              Namespace.current.foobara_lookup_type!(type).target_class
             end
           end
+
+          def expected_type_symbol
+            :model
+          end
+
+          def build_method(_symbolized_attributes)
+            :new
+          end
         end
       end
     end

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

@@ -25,7 +25,13 @@ module Foobara
             model_class_name = parent_declaration_data[:model_class]
 
             if model_class_name
-              Object.const_get(model_class_name).possible_errors
+              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
             else
               super
             end

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

@@ -15,100 +15,78 @@ module Foobara
             Foobara::Model
           end
 
+          # TODO: considerg splitting this up into multiple desugarizers
           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)
-                                   when nil
-                                     Object
-                                   else
-                                     # :nocov:
-                                     raise ArgumentError,
-                                           "expected #{mod} to be a module or module name"
-                                     # :nocov:
+            if strictish_type_declaration.key?(:model_module)
+              model_module = strictish_type_declaration[:model_module]
+
+              strictish_type_declaration[:model_module] =
+                case model_module
+                when ::Module
+                  model_module.name
+                when ::String, nil
+                  model_module
+                else
+                  # :nocov:
+                  raise ArgumentError, "expected #{model_module} to be a module or module name"
+                  # :nocov:
+                end
+            end
+
+            if strictish_type_declaration.key?(:model_class)
+              klass = strictish_type_declaration[:model_class]
+
+              model_class_name = if klass && Object.const_defined?(klass) && Object.const_get(klass).is_a?(::Class)
+                                   model_class = Object.const_get(klass)
+
+                                   unless strictish_type_declaration[:model_module]
+                                     model_module = Util.module_for(model_class)
+
+                                     unless model_module == Object
+                                       strictish_type_declaration[:model_module] = model_module&.name
+                                     end
                                    end
 
-                             if mod == GlobalDomain
-                               Object
-                             else
-                               mod
-                             end
-                           else
-                             Object
-                           end
-
-            model_class = if 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[:model_base_class] = model_class.superclass.name
+
+                                   model_class.name
+                                 elsif klass.is_a?(::String)
+                                   klass
+                                 else
+                                   # :nocov:
+                                   raise ArgumentError, "expected #{klass} to be a class or class name"
+                                   # :nocov:
+                                 end
+
+              strictish_type_declaration[:model_class] = model_class_name
+            end
+
+            model_base_class = strictish_type_declaration[:model_base_class] || default_model_base_class
+
+            strictish_type_declaration[:model_base_class] =
+              case model_base_class
+              when ::Class
+                model_base_class.name || model_base_class.model_name
+              when ::String
+                model_base_class
+              else
+                # :nocov:
+                raise ArgumentError, "expected #{model_base_class} to be a class or class name"
+                # :nocov:
+              end
+
+            if strictish_type_declaration[:name].is_a?(::Symbol)
+              strictish_type_declaration[:name] = strictish_type_declaration[:name].to_s
+            end
+
+            strictish_type_declaration[:model_class] ||= [
+              *strictish_type_declaration[:model_module],
+              strictish_type_declaration[:name]
+            ].join("::")
 
             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

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

@@ -5,7 +5,21 @@ module Foobara
         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])
+            model_class_name = strict_type_declaration[:model_class]
+
+            if Object.const_defined?(model_class_name) && Object.const_get(model_class_name).is_a?(::Class)
+              Object.const_get(model_class_name)
+            else
+              base_class_name = strict_type_declaration[:model_base_class]
+
+              base_class = if Object.const_defined?(base_class_name)
+                             Object.const_get(base_class_name)
+                           else
+                             foobara_domain.foobara_lookup_type!(base_class_name).target_class
+                           end
+
+              base_class.subclass(name: model_class_name)
+            end
           end
 
           # TODO: must explode if name missing...
@@ -32,14 +46,13 @@ module Foobara
                 model_class = type.target_class
                 existing_model_type = model_class.model_type
 
-                domain = model_class.domain || Domain.global
-
                 if existing_model_type
                   # :nocov:
                   raise "Did not expect #{type.declaration_data[:name]} to already exist"
                   # :nocov:
                 else
                   model_class.model_type = type
+                  domain = model_class.domain
                   type.type_symbol = type.declaration_data[:name]
                   model_class.description type.declaration_data[:description]
                   domain.foobara_register_model(model_class)

data/projects/model/src/model.rb

@@ -9,6 +9,7 @@ module Foobara
     include Concerns::Types
     include Concerns::Reflection
     include Concerns::Aliases
+    include Concerns::Classes
 
     class << self
       attr_accessor :is_abstract
@@ -65,7 +66,29 @@ module Foobara
 
       def domain
         if model_type
-          model_type.foobara_domain
+          domain = model_type.foobara_domain
+
+          if domain == GlobalDomain
+            module_name = model_type.declaration_data[:model_module]
+
+            begin
+              Domain.to_domain(module_name)
+            rescue Domain::NoSuchDomain
+              module_to_check = module_name
+
+              loop do
+                domain = if Object.const_defined?(module_to_check)
+                           return Domain.domain_through_modules(Object.const_get(module_to_check))
+                         elsif module_to_check.include?("::")
+                           module_to_check = module_to_check.split("::")[..-2].join("::")
+                         else
+                           return GlobalDomain
+                         end
+              end
+            end
+          else
+            domain
+          end
         else
           Domain.domain_through_modules(self)
         end
@@ -86,15 +109,19 @@ module Foobara
       end
 
       def foobara_model_name
-        foobara_type&.scoped_name || Util.non_full_name(self)
-      rescue Foobara::Scoped::NoScopedPathSetError
-        # :nocov:
-        Util.non_full_name(self)
-        # :nocov:
+        if foobara_type&.scoped_path_set?
+          foobara_type.scoped_name
+        else
+          Util.non_full_name(self) || model_name&.split("::")&.last
+        end
+      end
+
+      def foobara_name
+        foobara_model_name
       end
 
       def full_model_name
-        model_type&.scoped_full_name
+        [*model_type&.scoped_full_name, model_name].max_by(&:size)
       end
 
       def possible_errors(mutable: true)
@@ -123,46 +150,17 @@ module Foobara
         end
       end
 
-      def allowed_subclass_opts
-        %i[name model_module]
-      end
-
-      def subclass(**opts)
-        invalid_opts = opts.keys - allowed_subclass_opts
-
-        unless invalid_opts.empty?
-          # :nocov:
-          raise ArgumentError, "Invalid opts #{invalid_opts} expected only #{allowed_subclass_opts}"
-          # :nocov:
-        end
-
-        model_name = opts[:name]
-
-        if model_name.is_a?(::Symbol)
-          model_name = model_name.to_s
-        end
+      # will create an anonymous subclass
+      # TODO: change to a normal parameter since it's just name
+      def subclass(name:)
+        name = name.to_s if name.is_a?(::Symbol)
 
         # TODO: How are we going to set the domain and organization?
-        model_class = Class.new(self) do
+        Class.new(self) do
           singleton_class.define_method :model_name do
-            model_name
-          end
-        end
-
-        if opts.key?(:model_module)
-          model_module = opts[:model_module]
-
-          if model_name.include?("::")
-            model_module_name = "#{model_module.name}::#{model_name.split("::")[..-2].join("::")}"
-            model_module = Util.make_module_p(model_module_name, tag: true)
+            name
           end
-
-          const_name = model_name.split("::").last
-
-          model_module.const_set(const_name, model_class)
         end
-
-        model_class
       end
     end
 

data/projects/value/src/processor/casting.rb

@@ -61,7 +61,20 @@ module Foobara
         def does_not_need_cast_processor
           return @does_not_need_cast_processor if defined?(@does_not_need_cast_processor)
 
-          class_name = "NoCastNeededIfIsA#{target_classes.map { |c| c.name.gsub("::", "") }.sort.join("Or")}"
+          errorified_name = target_classes.map do |c|
+            if c.name
+              c.name
+            elsif c.respond_to?(:foobara_name)
+              c.foobara_name
+            else
+              # TODO: test this code path
+              # :nocov:
+              "Anon"
+              # :nocov:
+            end
+          end.map { |name| name.split("::").last }.sort.join("Or")
+
+          class_name = "NoCastNeededIfIsA#{errorified_name}"
 
           @does_not_need_cast_processor = if target_classes && !target_classes.empty?
                                             Caster.subclass(

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: foobara
 version: !ruby/object:Gem::Version
-  version: 0.0.80
+  version: 0.0.81
 platform: ruby
 authors:
 - Miles Georgi
 bindir: bin
 cert_chain: []
-date: 2025-03-19 00:00:00.000000000 Z
+date: 2025-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -295,6 +295,7 @@ files:
 - projects/manifest/src/foobara/manifest/type_declaration.rb
 - projects/model/lib/foobara/model.rb
 - projects/model/src/concerns/aliases.rb
+- projects/model/src/concerns/classes.rb
 - projects/model/src/concerns/reflection.rb
 - projects/model/src/concerns/types.rb
 - projects/model/src/extensions/builtin_types/model/casters/hash.rb