foobara 0.0.14 → 0.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38b777d54529187c23d8a7f67337c5cb6f841d06ca01efe3635c003359f38b47
-  data.tar.gz: 91bbdf579b22f6c2978180142846d8d5f14a7751840cc89b6b06d70248247f33
+  metadata.gz: a386511b5dd07ad9a067ce02cdf7dfef7436a9db51fe938e26e1dec2c42b836f
+  data.tar.gz: bf3f4960d49e6ca8f9a17ee7f4ceb7d3f04dd433172bc0028d8314081c933049
 SHA512:
-  metadata.gz: f06ee9edaf6d45318abe7ad05b1a9932895443eb72a42d8fe25baa0ad5c2b666f1bacc38a14ea1d390bb75f5283ec64ccf77e2f0a3be1cc05b67e95422220371
-  data.tar.gz: 1facc5ea85dfab04ec0f97d96090c512c75cb676cdebde0ebbed0c981d01d4cc8780d1c2533fb2f74b8322e0c62db0caa81a838ab8d09619458d943985dee065
+  metadata.gz: 7cd69b5365baa7bb77534875bed988c638b2c48d79d28119337adca49c8a2551bd958bd3835da682fc143d57186ba7efbf8a36630fc573d0991ae0c10c4cf6bb
+  data.tar.gz: e00097bd3e762179bd14bfa9e292a2b93c6f063d5dd67b82ec6942d7578af206dd97322a560a7f0e9771bb5b799d2acb34d07e08db4d3f46f6f22ab48f2be642

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## [0.0.16] - 2024-11-22
+
+- Fix bug where mutable not being set explicitly raises
+- Also, make it so models don't default to mutable false when processed by a model type
+
+## [0.0.15] - 2024-11-20
+
+- Move entity attributes type declaration helpers from Command::EntityHelpers to Entity for convenience.
+
 ## [0.0.14] - 2024-11-15
 
 - Provide a default execute because why not...

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

@@ -0,0 +1,190 @@
+module Foobara
+  class Entity < Model
+    module Concerns
+      module AttributeHelpers
+        include Foobara::Concern
+
+        def update_aggregate(value, type = self.class.model_type)
+          # is this a smell?
+          self.class.update_aggregate(self, value, type)
+        end
+
+        module ClassMethods
+          def attributes_for_update
+            attributes_for_aggregate_update
+          end
+
+          # TODO: we should have metadata on the entity about whether it required a primary key
+          # upon creation or not instead of an option here.
+          def attributes_for_create(includes_primary_key: false)
+            return attributes_type if includes_primary_key
+
+            declaration = attributes_type.declaration_data
+            # TODO: just slice out the element type declarations
+            declaration = Util.deep_dup(declaration)
+
+            if declaration.key?(:required) && declaration[:required].include?(primary_key_attribute)
+              declaration[:required].delete(primary_key_attribute)
+            end
+
+            if declaration.key?(:defaults) && declaration[:defaults].include?(primary_key_attribute)
+              declaration[:defaults].delete(primary_key_attribute)
+            end
+
+            if declaration.key?(:element_type_declarations)
+              if declaration[:element_type_declarations].key?(primary_key_attribute)
+                declaration[:element_type_declarations].delete(primary_key_attribute)
+              end
+            end
+
+            handler = Domain.global.foobara_type_builder.handler_for_class(
+              TypeDeclarations::Handlers::ExtendAttributesTypeDeclaration
+            )
+
+            handler.desugarize(declaration)
+          end
+
+          def attributes_for_aggregate_update(initial = true)
+            declaration = attributes_type.declaration_data
+            # TODO: just slice out the element type declarations
+            declaration = Util.deep_dup(declaration)
+
+            declaration.delete(:defaults)
+            declaration.delete(:required)
+
+            if initial
+              declaration[:required] = [primary_key_attribute]
+            end
+
+            associations.each_pair do |data_path, type|
+              if type.extends?(BuiltinTypes[:entity])
+                target_class = type.target_class
+
+                entry = type_declaration_value_at(declaration, DataPath.new(data_path).path)
+                entry.clear
+                entry.merge!(target_class.attributes_for_aggregate_update(false))
+              end
+            end
+
+            declaration
+          end
+
+          def attributes_for_atom_update
+            declaration = attributes_type.declaration_data
+            # TODO: just slice out the element type declarations
+            declaration = Util.deep_dup(declaration)
+
+            declaration.delete(:defaults)
+            declaration[:required] = [primary_key_attribute]
+
+            # expect all associations to be expressed as primary key values
+            # TODO: should we have a special type for encapsulating primary keys types??
+            associations.each_pair do |data_path, type|
+              if type.extends?(BuiltinTypes[:entity])
+                target_class = type.target_class
+                # TODO: do we really need declaration_data? Why cant we use the type directly?
+                # TODO: make this work with the type directly for performance reasons.
+                primary_key_type_declaration = target_class.primary_key_type.declaration_data
+                entry = type_declaration_value_at(declaration, DataPath.new(data_path).path)
+                entry.clear
+                entry.merge!(primary_key_type_declaration)
+              end
+            end
+
+            declaration
+          end
+
+          def attributes_for_find_by
+            element_type_declarations = {}
+
+            attributes_type.element_types.each_pair do |attribute_name, attribute_type|
+              element_type_declarations[attribute_name] = attribute_type.reference_or_declaration_data
+            end
+
+            handler = Domain.global.foobara_type_builder.handler_for_class(
+              TypeDeclarations::Handlers::ExtendAttributesTypeDeclaration
+            )
+
+            handler.desugarize(
+              type: "::attributes",
+              element_type_declarations:
+            )
+          end
+
+          def update_aggregate(object, value, type = object.class.model_type)
+            return value if object.nil?
+
+            if type.extends?(BuiltinTypes[:model])
+              element_types = type.element_types.element_types
+
+              value.each_pair do |attribute_name, new_value|
+                current_value = object.read_attribute(attribute_name)
+
+                attribute_type = element_types[attribute_name]
+
+                updated_value = update_aggregate(current_value, new_value, attribute_type)
+
+                object.write_attribute(attribute_name, updated_value)
+              end
+
+              object
+            elsif type.extends?(BuiltinTypes[:attributes])
+              element_types = type.element_types
+
+              object = object.dup
+              object ||= {}
+
+              value.each_pair do |attribute_name, new_value|
+                current_value = object[attribute_name]
+                attribute_type = element_types[attribute_name]
+
+                updated_value = update_aggregate(current_value, new_value, attribute_type)
+
+                object[attribute_name] = updated_value
+              end
+
+              object
+            elsif type.extends?(BuiltinTypes[:tuple])
+              # :nocov:
+              raise "Tuple not yet supported"
+            # :nocov:
+            elsif type.extends?(BuiltinTypes[:associative_array])
+              # :nocov:
+              raise "Associated array not yet supported"
+            # :nocov:
+            elsif type.extends?(BuiltinTypes[:array])
+              element_type = type.element_type
+
+              value.map.with_index do |element, index|
+                update_aggregate(object[index], element, element_type)
+              end
+            else
+              value
+            end
+          end
+
+          private
+
+          def type_declaration_value_at(declaration, path_parts)
+            return declaration if path_parts.empty?
+
+            path_part, *path_parts = path_parts
+
+            declaration = case path_part
+                          when :"#"
+                            declaration[:element_type_declaration]
+                          when Symbol, Integer
+                            declaration[:element_type_declarations][path_part]
+                          else
+                            # :nocov:
+                            raise "Bad path part #{path_part}"
+                            # :nocov:
+                          end
+
+            type_declaration_value_at(declaration, path_parts)
+          end
+        end
+      end
+    end
+  end
+end

data/projects/entity/src/entity.rb

@@ -12,6 +12,7 @@ module Foobara
     include Concerns::Persistence
     include Concerns::Initialization
     include Concerns::Reflection
+    include Concerns::AttributeHelpers
 
     class << self
       prepend NewPrepend

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

@@ -2,6 +2,7 @@ module Foobara
   module BuiltinTypes
     module Entity
       module Casters
+        # TODO: We need a way of disabling/enabling this and it should probably be disabled by default.
         class Hash < Attributes::Casters::Hash
           class << self
             def requires_parent_declaration_data?

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

@@ -11,11 +11,19 @@ module Foobara
           end
 
           def transform(record)
-            record.mutable = if parent_declaration_data.key?(:mutable)
-                               parent_declaration_data[:mutable]
-                             else
-                               false
-                             end
+            if parent_declaration_data.key?(:mutable)
+              # hmmmm.... can we really just arbitrarily clobber this?
+              # wouldn't that be surprising to calling code that passes in a record/model?
+              # One use-case of this seems to be to reduce the amount of possible errors a command reports
+              # by declaring that only some subset or none of the attributes are mutable.
+              # However, we shouldn't react to this by clobbering the mutable state of the record because it might not
+              # be a fresh record fetched from a primary key it might be an already loaded record/model from some other
+              # context and that context might be surprised to learn that we've clobbered its mutability status.
+              # Solutions?
+              # 1. In the case of models, we could duplicate the model if the mutable value is different.
+              # 2. But what about entities? We almost need some sort of proxy entity that tightens the mutability?
+              record.mutable = parent_declaration_data[:mutable]
+            end
 
             record
           end

data/projects/model/src/model.rb

@@ -207,6 +207,7 @@ module Foobara
         end
       end
 
+      # why do we default to true here but false in the transformers?
       mutable = options.key?(:mutable) ? options[:mutable] : true
 
       self.mutable = if mutable.is_a?(::Array)
@@ -227,7 +228,7 @@ module Foobara
     def write_attribute(attribute_name, value)
       attribute_name = attribute_name.to_sym
 
-      if mutable == true || mutable.include?(attribute_name)
+      if mutable == true || mutable&.include?(attribute_name)
         outcome = cast_attribute(attribute_name, value)
         attributes[attribute_name] = outcome.success? ? outcome.result : value
       else

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: foobara
 version: !ruby/object:Gem::Version
-  version: 0.0.14
+  version: 0.0.16
 platform: ruby
 authors:
 - Miles Georgi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-16 00:00:00.000000000 Z
+date: 2024-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: foobara-util
@@ -116,7 +116,6 @@ files:
 - projects/callback/src/set.rb
 - projects/command/lib/foobara/command.rb
 - projects/command/src/command.rb
-- projects/command/src/command/entity_helpers.rb
 - projects/command/src/concerns/callbacks.rb
 - projects/command/src/concerns/description.rb
 - projects/command/src/concerns/domain_mappers.rb
@@ -187,6 +186,7 @@ files:
 - projects/domain/src/organization_module_extension.rb
 - projects/entity/lib/foobara/entity.rb
 - projects/entity/src/concerns/associations.rb
+- projects/entity/src/concerns/attribute_helpers.rb
 - projects/entity/src/concerns/attributes.rb
 - projects/entity/src/concerns/callbacks.rb
 - projects/entity/src/concerns/initialization.rb

data/projects/command/src/command/entity_helpers.rb

@@ -1,184 +0,0 @@
-module Foobara
-  class Command
-    module EntityHelpers
-      module_function
-
-      # Just for convenience
-      def attributes_for_update(entity_class)
-        type_declaration_for_record_aggregate_update(entity_class)
-      end
-
-      # TODO: we should have metadata on the entity about whether it required a primary key
-      # upon creation or not instead of an option here.
-      def attributes_for_create(entity_class, includes_primary_key: false)
-        attributes_type = entity_class.attributes_type
-
-        return attributes_type if includes_primary_key
-
-        declaration = attributes_type.declaration_data
-        # TODO: just slice out the element type declarations
-        declaration = Util.deep_dup(declaration)
-
-        primary_key_attribute = entity_class.primary_key_attribute
-
-        if declaration.key?(:required) && declaration[:required].include?(primary_key_attribute)
-          declaration[:required].delete(primary_key_attribute)
-        end
-
-        if declaration.key?(:defaults) && declaration[:defaults].include?(primary_key_attribute)
-          declaration[:defaults].delete(primary_key_attribute)
-        end
-
-        if declaration.key?(:element_type_declarations)
-          if declaration[:element_type_declarations].key?(primary_key_attribute)
-            declaration[:element_type_declarations].delete(primary_key_attribute)
-          end
-        end
-
-        handler = Domain.global.foobara_type_builder.handler_for_class(
-          TypeDeclarations::Handlers::ExtendAttributesTypeDeclaration
-        )
-
-        handler.desugarize(declaration)
-      end
-
-      def type_declaration_for_record_aggregate_update(entity_class, initial = true)
-        declaration = entity_class.attributes_type.declaration_data
-        # TODO: just slice out the element type declarations
-        declaration = Util.deep_dup(declaration)
-
-        declaration.delete(:defaults)
-        declaration.delete(:required)
-
-        if initial
-          declaration[:required] = [entity_class.primary_key_attribute]
-        end
-
-        entity_class.associations.each_pair do |data_path, type|
-          if type.extends?(BuiltinTypes[:entity])
-            target_class = type.target_class
-
-            entry = type_declaration_value_at(declaration, DataPath.new(data_path).path)
-            entry.clear
-            entry.merge!(type_declaration_for_record_aggregate_update(target_class, false))
-          end
-        end
-
-        declaration
-      end
-
-      def type_declaration_for_record_atom_update(entity_class)
-        declaration = entity_class.attributes_type.declaration_data
-        # TODO: just slice out the element type declarations
-        declaration = Util.deep_dup(declaration)
-
-        declaration.delete(:defaults)
-        declaration[:required] = [entity_class.primary_key_attribute]
-
-        # expect all associations to be expressed as primary key values
-        # TODO: should we have a special type for encapsulating primary keys types??
-        entity_class.associations.each_pair do |data_path, type|
-          if type.extends?(BuiltinTypes[:entity])
-            target_class = type.target_class
-            # TODO: do we really need declaration_data? Why cant we use the type directly?
-            # TODO: make this work with the type directly for performance reasons.
-            primary_key_type_declaration = target_class.primary_key_type.declaration_data
-            entry = type_declaration_value_at(declaration, DataPath.new(data_path).path)
-            entry.clear
-            entry.merge!(primary_key_type_declaration)
-          end
-        end
-
-        declaration
-      end
-
-      def type_declaration_for_find_by(entity_class)
-        element_type_declarations = {}
-
-        entity_class.attributes_type.element_types.each_pair do |attribute_name, attribute_type|
-          element_type_declarations[attribute_name] = attribute_type.reference_or_declaration_data
-        end
-
-        handler = Domain.global.foobara_type_builder.handler_for_class(
-          TypeDeclarations::Handlers::ExtendAttributesTypeDeclaration
-        )
-
-        handler.desugarize(
-          type: "::attributes",
-          element_type_declarations:
-        )
-      end
-
-      def update_aggregate(object, value, type = object.class.model_type)
-        return value if object.nil?
-
-        if type.extends?(BuiltinTypes[:model])
-          element_types = type.element_types.element_types
-
-          value.each_pair do |attribute_name, new_value|
-            current_value = object.read_attribute(attribute_name)
-
-            attribute_type = element_types[attribute_name]
-
-            updated_value = update_aggregate(current_value, new_value, attribute_type)
-
-            object.write_attribute(attribute_name, updated_value)
-          end
-
-          object
-        elsif type.extends?(BuiltinTypes[:attributes])
-          element_types = type.element_types
-
-          object = object.dup
-          object ||= {}
-
-          value.each_pair do |attribute_name, new_value|
-            current_value = object[attribute_name]
-            attribute_type = element_types[attribute_name]
-
-            updated_value = update_aggregate(current_value, new_value, attribute_type)
-
-            object[attribute_name] = updated_value
-          end
-
-          object
-        elsif type.extends?(BuiltinTypes[:tuple])
-          # :nocov:
-          raise "Tuple not yet supported"
-        # :nocov:
-        elsif type.extends?(BuiltinTypes[:associative_array])
-          # :nocov:
-          raise "Associated array not yet supported"
-        # :nocov:
-        elsif type.extends?(BuiltinTypes[:array])
-          element_type = type.element_type
-
-          value.map.with_index do |element, index|
-            update_aggregate(object[index], element, element_type)
-          end
-        else
-          value
-        end
-      end
-
-      def type_declaration_value_at(declaration, path_parts)
-        return declaration if path_parts.empty?
-
-        path_part, *path_parts = path_parts
-
-        declaration = case path_part
-                      when :"#"
-                        declaration[:element_type_declaration]
-                      when Symbol, Integer
-                        declaration[:element_type_declarations][path_part]
-                      else
-                        # :nocov:
-                        raise "Bad path part #{path_part}"
-                        # :nocov:
-                      end
-
-        type_declaration_value_at(declaration, path_parts)
-      end
-    end
-  end
-end