foobara 0.0.13 → 0.0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a0fe6b2415dddaf6742ae9bd3809f807148d61a8595eff27c7053b7bdf2120b0
-  data.tar.gz: a0b48950e37a936d2b4aae09ab9fe5bceaed5ae46da724a7f0d64bfe4177e549
+  metadata.gz: cec596f3e023a3bb6381c2f4406f6419d15cdeae3b9b1c7140a74ea8d999b4e4
+  data.tar.gz: 7d493bb518a6892cbc483bbdedaa0301e2986a8c90d03249dd9abf2210b52032
 SHA512:
-  metadata.gz: 67a4249c5ca81daad7c7476eac81dafdea51224135e3e224ca31a4def8a0dc9906a79f4f4500f95a75446073ceccbab6d4ada74fca656bec305aebe7b2b546f7
-  data.tar.gz: da74f67ea8f39814874c2393c45ff514fd669dbd9865acbf7da4414e2ed702d9a9522d4381343f2201d6804f1b3d31565fa48926e5cf751f3376e8d7bd7069d4
+  metadata.gz: f869b1e7749e1388c86de79964d0031eb0bddb00eea9c477bc8336aa41d2941571dceaa506a16fbd9f8dee479e2cf6e708542fb938bae3cc295d8dddc4909a29
+  data.tar.gz: 7755a9dfe9587cbcf7726ba1d25397012e31a6123efa97c8141b63d703c42af56df007d4fd22e604da0b1f05d4f2d84e3484f718c00d917863803921d47aecd7

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## [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...
+- Allow require "foobara" instead of require "foobara/all"
+
 ## [0.0.13] - 2024-11-13
 
 - Do not fail :one_of if it is nil and :allows_nil

data/projects/command/src/concerns/runtime.rb

@@ -71,6 +71,9 @@ module Foobara
           @outcome = Outcome.success(result)
         end
 
+        def execute
+        end
+
         def succeed
           # noop but for now helpful for carrying out state transition
         end

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/foobara/lib/foobara.rb

@@ -0,0 +1,4 @@
+require "foobara/all"
+
+module Foobara
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: foobara
 version: !ruby/object:Gem::Version
-  version: 0.0.13
+  version: 0.0.15
 platform: ruby
 authors:
 - Miles Georgi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-14 00:00:00.000000000 Z
+date: 2024-11-20 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
@@ -214,6 +214,7 @@ files:
 - projects/enumerated/lib/foobara/enumerated.rb
 - projects/enumerated/src/accessors.rb
 - projects/enumerated/src/values.rb
+- projects/foobara/lib/foobara.rb
 - projects/foobara/lib/foobara/all.rb
 - projects/in_memory_crud_driver/lib/foobara/in_memory_crud_driver.rb
 - projects/in_memory_crud_driver/src/in_memory.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