foobara 0.0.141 → 0.1.1

data/projects/persistence/src/entity_base/transaction.rb

@@ -62,7 +62,20 @@ module Foobara
             # :nocov:
           end
 
-          tables[entity_class] ||= TransactionTable.new(self, entity_class)
+          table = tables[entity_class]
+
+          if table
+            table
+          else
+            if defined?(@ordered_tables)
+              # TODO: test this path
+              # :nocov:
+              remove_instance_variable(:@ordered_tables)
+              # :nocov:
+            end
+
+            tables[entity_class] = TransactionTable.new(self, entity_class)
+          end
         end
 
         def updated(record)
@@ -149,16 +162,6 @@ module Foobara
           table_for(entity).track_created(entity)
         end
 
-        def created?(record)
-          table_for(record).created?(record)
-        end
-
-        # WARNING! this seems to bypass validations, hmmm....
-        def flush_created_record!(record)
-          table_for(record).flush_created_record!(record)
-        end
-
-        # convenience method...
         def perform(&)
           entity_base.using_transaction(self, &)
         end

data/projects/persistence/src/entity_base/transaction_table.rb

@@ -642,11 +642,12 @@ module Foobara
 
         def flush_created!
           marked_created.each do |record|
-            flush_created_associations!(record)
-
             # TODO: do this in bulk
             attributes = entity_attributes_crud_driver_table.insert(to_persistable(record))
-            record.write_attributes_without_callbacks(attributes)
+            primary_key_attribute = entity_class.primary_key_attribute
+            primary_key = attributes[primary_key_attribute]
+
+            record.write_attributes_without_callbacks(primary_key_attribute => primary_key)
 
             # we need to update finding the tracked object by key and removing/reading it seems to be the simplest
             # way to accomplish that at the moment
@@ -660,48 +661,10 @@ module Foobara
           marked_created.clear
         end
 
-        def flush_created_record!(record)
-          flush_created_associations!(record)
-
-          unmark_created(record)
-
-          attributes = entity_attributes_crud_driver_table.insert(to_persistable(record))
-          record.write_attributes_without_callbacks(attributes)
-
-          # we need to update finding the tracked object by key and removing/reading it seems to be the simplest
-          # way to accomplish that at the moment
-          tracked(record)
-
-          record.is_persisted = record.is_loaded = true
-          record.is_created = false
-          record.save_persisted_attributes
-        end
-
-        def flush_created_associations!(record)
-          entity_class.associations.each_key do |association_data_path|
-            DataPath.values_at(association_data_path, record).each do |associated_record|
-              next unless associated_record.created?
-
-              transaction = Persistence::EntityBase::Transaction.open_transaction_for(associated_record)
-
-              unless transaction
-                # :nocov:
-                raise "No open transaction for #{associated_record}"
-                # :nocov:
-              end
-
-              if transaction.created?(associated_record)
-                transaction.flush_created_record!(associated_record)
-              end
-            end
-          end
-        end
-
         def flush_updated_and_hard_deleted!
           # TODO: use bulk operations to improve performance...
           marked_updated.each do |record|
-            attributes = entity_attributes_crud_driver_table.update(to_persistable(record))
-            record.write_attributes_without_callbacks(attributes)
+            entity_attributes_crud_driver_table.update(to_persistable(record))
             record.save_persisted_attributes
           end
 
@@ -753,16 +716,14 @@ module Foobara
 
         def normalize_attributes(attributes)
           if attributes
-            begin
-              attributes = attributes.transform_keys(&:to_sym)
+            attributes = attributes.transform_keys(&:to_sym)
 
-              primary_key_name = entity_class.primary_key_attribute
-              primary_key_value = attributes[primary_key_name]
+            primary_key_name = entity_class.primary_key_attribute
+            primary_key_value = attributes[primary_key_name]
 
-              attributes[primary_key_name] = entity_class.primary_key_type.cast!(primary_key_value)
+            attributes[primary_key_name] = entity_class.primary_key_type.cast!(primary_key_value)
 
-              attributes
-            end
+            attributes
           end
         end
       end

data/projects/persistence/src/entity_base.rb

@@ -21,6 +21,45 @@ module Foobara
             end.call
           end
         end
+
+        def order_entity_classes(entity_classes)
+          return entity_classes if entity_classes.size <= 1
+
+          without_associations, with_associations = entity_classes.partition do |entity_class|
+            entity_class.associations.empty?
+          end
+
+          if with_associations.size > 1
+            i = 0
+            end_at = with_associations.size - 1
+
+            while i < end_at
+              entity_class = with_associations[i]
+              associations = entity_class.associations.values.uniq
+
+              changed = false
+
+              j = i + 1
+
+              while j <= end_at
+                other = with_associations[j]
+
+                if associations.include?(other.foobara_type)
+                  with_associations[j] = entity_class
+                  with_associations[i] = other
+                  changed = true
+                  break
+                end
+
+                j += 1
+              end
+
+              i += 1 unless changed
+            end
+          end
+
+          without_associations + with_associations
+        end
       end
 
       def initialize(name, entity_attributes_crud_driver:)

data/projects/persistence/src/persistence.rb

@@ -99,6 +99,10 @@ module Foobara
       end
 
       def objects_to_bases(objects)
+        if objects.size > 1 && objects.all? { |o| o.is_a?(::Class) && o < Entity }
+          objects = EntityBase.order_entity_classes(objects)
+        end
+
         objects.map do |object|
           object_to_base(object)
         end.uniq

data/projects/type_declarations/src/attributes.rb

@@ -25,12 +25,16 @@ module Foobara
             TypeDeclarations::Handlers::ExtendAttributesTypeDeclaration
           )
 
-          handler.desugarize(
-            type: "::attributes",
+          declaration = TypeDeclaration.new(
+            type: :attributes,
             element_type_declarations:,
             required:,
             defaults:
           )
+          declaration.is_absolutified = true
+          declaration.is_duped = true
+
+          handler.desugarize(declaration).declaration_data
         end
 
         def only(declaration, *keys)
@@ -49,9 +53,8 @@ module Foobara
           reject(declaration, keys_to_reject)
         end
 
-        def reject(declaration, *keys)
-          # TODO: do we really need a deep dup?
-          declaration = Util.deep_dup(declaration)
+        def reject(declaration_data, *keys)
+          declaration = TypeDeclaration.new(declaration_data)
 
           element_type_declarations = declaration[:element_type_declarations]
           required = declaration[:required]
@@ -64,17 +67,20 @@ module Foobara
 
             if element_type_declarations.key?(key)
               changed = true
-              element_type_declarations.delete(key)
+              declaration[:element_type_declarations] = declaration[:element_type_declarations].except(key)
             end
 
             if required&.include?(key)
               changed = true
+              required = required.dup
               required.delete(key)
+              declaration[:required] = required
             end
 
             if defaults&.key?(key)
               changed = true
-              defaults.delete(key)
+              defaults = defaults.except(key)
+              declaration[:defaults] = defaults
             end
           end
 
@@ -83,9 +89,9 @@ module Foobara
               TypeDeclarations::Handlers::ExtendAttributesTypeDeclaration
             )
 
-            handler.desugarize(declaration)
+            handler.desugarize(declaration).declaration_data
           else
-            declaration
+            declaration_data
           end
         end
       end

data/projects/type_declarations/src/attributes_transformers/from_yaml.rb

@@ -48,7 +48,7 @@ module Foobara
 
         declaration[:element_type_declarations].each_pair do |attribute_name, declaration_data|
           element_type_declarations[attribute_name] = if from_yaml.include?(attribute_name)
-                                                        { type: :string }
+                                                        :string
                                                       else
                                                         declaration_data
                                                       end

data/projects/type_declarations/src/desugarizer_pipeline.rb

@@ -0,0 +1,9 @@
+module Foobara
+  module TypeDeclarations
+    class DesugarizerPipeline < Value::Processor::Pipeline
+      def applicable?(type_declaration)
+        !type_declaration.strict? && super
+      end
+    end
+  end
+end

data/projects/type_declarations/src/dsl/attributes.rb

@@ -117,7 +117,8 @@ module Foobara
               _add_attribute(attribute_name, type)
             else
               declaration = if block
-                              attributes_declaration = Attributes.to_declaration(&block).merge(declaration)
+                              attributes_declaration =
+                                Attributes.to_declaration(&block).declaration_data.merge(declaration)
 
                               if type == :array
                                 {
@@ -173,13 +174,21 @@ module Foobara
 
         def _type_declaration
           @_type_declaration ||= begin
-            sugar = {
-              type: "::attributes",
+            declaration = TypeDeclaration.new(
+              type: :attributes,
               element_type_declarations: {}
-            }
+            )
+
+            declaration.is_absolutified = true
+            declaration.is_duped = true
 
             handler = Domain.current.foobara_type_builder.handler_for_class(Handlers::ExtendAttributesTypeDeclaration)
-            handler.desugarize(sugar)
+            declaration = handler.desugarize(declaration)
+
+            declaration.is_strict = false
+            declaration.is_absolutified = true
+
+            declaration
           end
         end
       end

data/projects/type_declarations/src/handlers/extend_array_type_declaration/array_desugarizer.rb

@@ -8,18 +8,38 @@ module Foobara
         # TODO: make a quick way to convert a couple simple procs into a transformer
         class ArrayDesugarizer < TypeDeclarations::Desugarizer
           def applicable?(sugary_type_declaration)
-            sugary_type_declaration.is_a?(::Array) && sugary_type_declaration.size <= 1
+            sugary_type_declaration.array? && sugary_type_declaration.size <= 1 && !sugary_type_declaration.strict?
           end
 
           def desugarize(sugary_type_declaration)
-            strict_type_declaration = { type: :array, _desugarized: { type_absolutified: true } }
+            strict_type_declaration = sugary_type_declaration
+            sugary_type_declaration = sugary_type_declaration.declaration_data
+
+            strict_type_declaration.declaration_data = { type: :array }
+            strict_type_declaration.is_duped = true
+            strict_type_declaration.is_absolutified = true
 
             unless sugary_type_declaration.empty?
               element_type_declaration = sugary_type_declaration.first
 
-              handler = type_declaration_handler_for(element_type_declaration)
+              element_type_declaration = if element_type_declaration.is_a?(Types::Type)
+                                           element_type_declaration.reference_or_declaration_data
+                                         else
+                                           declaration = TypeDeclaration.new(element_type_declaration)
+
+                                           if strict_type_declaration.deep_duped?
+                                             # TODO: probably not worth directly testing this path
+                                             # :nocov:
+                                             declaration.is_deep_duped = true
+                                             declaration.is_duped = true
+                                             # :nocov:
+                                           end
+
+                                           handler = type_declaration_handler_for(declaration)
+                                           handler.desugarize(declaration).declaration_data
+                                         end
 
-              strict_type_declaration[:element_type_declaration] = handler.desugarize(element_type_declaration)
+              strict_type_declaration[:element_type_declaration] = element_type_declaration
             end
 
             strict_type_declaration

data/projects/type_declarations/src/handlers/extend_array_type_declaration/element_type_declaration_desugarizer.rb

@@ -4,23 +4,37 @@ module Foobara
       class ExtendArrayTypeDeclaration < ExtendAssociativeArrayTypeDeclaration
         class ElementTypeDeclarationDesugarizer < 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 false unless sugary_type_declaration.key?(:type)
+            return false if sugary_type_declaration.strict?
+            return false unless sugary_type_declaration.hash?
+            return false unless sugary_type_declaration.all_symbolizable_keys?
 
             type_symbol = sugary_type_declaration[:type]
 
-            type_symbol == :array && sugary_type_declaration.key?(:element_type_declaration)
+            type_symbol.is_a?(::Symbol) && type_symbol == :array &&
+              sugary_type_declaration.key?(:element_type_declaration)
           end
 
           def desugarize(sugary_type_declaration)
+            sugary_type_declaration.symbolize_keys!
+
             sugar = sugary_type_declaration[:element_type_declaration]
 
-            handler = type_declaration_handler_for(sugar)
-            strict = handler.desugarize(sugar)
+            strict = if sugar.is_a?(Types::Type)
+                       sugar.reference_or_declaration_data
+                     else
+                       declaration = sugary_type_declaration.clone_from_part(sugar)
+
+                       if sugary_type_declaration.deep_duped?
+                         # TODO: probably not worth directly testing this path
+                         # :nocov:
+                         declaration.is_deep_duped = true
+                         declaration.is_duped = true
+                         # :nocov:
+                       end
+
+                       handler = type_declaration_handler_for(declaration)
+                       handler.desugarize(declaration).declaration_data
+                     end
 
             sugary_type_declaration[:element_type_declaration] = strict
 

data/projects/type_declarations/src/handlers/extend_array_type_declaration/to_type_transformer.rb

@@ -7,13 +7,9 @@ module Foobara
       class ExtendArrayTypeDeclaration < ExtendAssociativeArrayTypeDeclaration
         class ToTypeTransformer < ExtendAssociativeArrayTypeDeclaration::ToTypeTransformer
           def transform(strict_type_declaration)
-            super.tap do |type|
-              element_type_declaration = type.declaration_data[:element_type_declaration]
-
-              if element_type_declaration
-                type.element_type = type_for_declaration(element_type_declaration)
-              end
-            end
+            type = super
+            type.element_type = :Array
+            type
           end
         end
       end

data/projects/type_declarations/src/handlers/extend_array_type_declaration/type_set_to_array_desugarizer.rb

@@ -7,21 +7,32 @@ module Foobara
         # TODO: make a quick way to convert a couple simple procs into a transformer
         class TypeSetToArrayDesugarizer < ArrayDesugarizer
           def applicable?(sugary_type_declaration)
-            if sugary_type_declaration.is_a?(::Hash) && sugary_type_declaration.key?(:type)
-              extra_keys = sugary_type_declaration.keys - [:type, :description, :sensitive, :sensitive_exposed]
+            if sugary_type_declaration.hash? && sugary_type_declaration.key?(:type)
+              extra_keys = sugary_type_declaration.declaration_data.keys -
+                           [:type, :description, :sensitive, :sensitive_exposed]
 
               return false if extra_keys.any?
 
               type = sugary_type_declaration[:type]
 
               if type.is_a?(::Array)
-                super(type)
+                super(TypeDeclaration.new(type))
               end
             end
           end
 
           def desugarize(sugary_type_declaration)
-            strict_type_declaration = super(sugary_type_declaration[:type])
+            strict_type_declaration = TypeDeclaration.new(sugary_type_declaration[:type])
+
+            if sugary_type_declaration.deep_duped?
+              # TODO: probably not worth testing this path
+              # :nocov:
+              strict_type_declaration.is_deep_duped = true
+              strict_type_declaration.is_duped = true
+              # :nocov:
+            end
+
+            strict_type_declaration = super(strict_type_declaration)
 
             if sugary_type_declaration.key?(:description)
               strict_type_declaration[:description] = sugary_type_declaration[:description]

data/projects/type_declarations/src/handlers/extend_array_type_declaration.rb

@@ -4,9 +4,19 @@ module Foobara
       # Hmmmm... this inheritance feels backwards
       class ExtendArrayTypeDeclaration < ExtendAssociativeArrayTypeDeclaration
         def applicable?(sugary_type_declaration)
-          strictish_type_declaration = desugarize(sugary_type_declaration)
+          strictish_type_declaration = if sugary_type_declaration.strict?
+                                         sugary_type_declaration
+                                       else
+                                         desugarize(sugary_type_declaration.clone)
+                                       end
 
-          strictish_type_declaration.is_a?(::Hash) && strictish_type_declaration[:type] == :array
+          if strictish_type_declaration.hash? && strictish_type_declaration[:type] == :array
+            unless strictish_type_declaration.equal?(sugary_type_declaration)
+              sugary_type_declaration.assign(strictish_type_declaration)
+            end
+
+            true
+          end
         end
       end
     end

data/projects/type_declarations/src/handlers/extend_associative_array_type_declaration/key_type_declaration_desugarizer.rb

@@ -0,0 +1,48 @@
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendAssociativeArrayTypeDeclaration < ExtendRegisteredTypeDeclaration
+        class KeyTypeDeclarationDesugarizer < TypeDeclarations::Desugarizer
+          def applicable?(sugary_type_declaration)
+            return false if sugary_type_declaration.strict?
+            return false unless sugary_type_declaration.hash?
+            return false unless sugary_type_declaration.all_symbolizable_keys?
+
+            type_symbol = sugary_type_declaration[:type]
+
+            type_symbol.is_a?(::Symbol) && type_symbol == :associative_array &&
+              sugary_type_declaration.key?(:key_type_declaration)
+          end
+
+          def desugarize(sugary_type_declaration)
+            sugary_type_declaration.symbolize_keys!
+
+            sugar = sugary_type_declaration[:key_type_declaration]
+
+            strict = if sugar.is_a?(Types::Type)
+                       sugar.reference_or_declaration_data
+                     else
+                       declaration = sugary_type_declaration.clone_from_part(sugar)
+
+                       if sugary_type_declaration.deep_duped?
+                         declaration.is_deep_duped = true
+                         declaration.is_duped = true
+                       end
+
+                       handler = type_declaration_handler_for(declaration)
+                       handler.desugarize(declaration).declaration_data
+                     end
+
+            sugary_type_declaration[:key_type_declaration] = strict
+
+            sugary_type_declaration
+          end
+
+          def priority
+            Priority::LOW
+          end
+        end
+      end
+    end
+  end
+end

data/projects/type_declarations/src/handlers/extend_associative_array_type_declaration/to_type_transformer.rb

@@ -9,17 +9,9 @@ module Foobara
       class ExtendAssociativeArrayTypeDeclaration < ExtendRegisteredTypeDeclaration
         class ToTypeTransformer < ExtendRegisteredTypeDeclaration::ToTypeTransformer
           def transform(strict_type_declaration)
-            super.tap do |type|
-              key_type_declaration = type.declaration_data[:key_type_declaration]
-              value_type_declaration = type.declaration_data[:value_type_declaration]
-
-              if key_type_declaration || value_type_declaration
-                type.element_types = [
-                  type_for_declaration(key_type_declaration || :duck),
-                  type_for_declaration(value_type_declaration || :duck)
-                ]
-              end
-            end
+            type = super
+            type.element_types = :Hash
+            type
           end
         end
       end

data/projects/type_declarations/src/handlers/extend_associative_array_type_declaration/value_type_declaration_desugarizer.rb

@@ -0,0 +1,51 @@
+require_relative "../extend_registered_type_declaration"
+require_relative "../../desugarizer"
+
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendAssociativeArrayTypeDeclaration < ExtendRegisteredTypeDeclaration
+        class ValueTypeDeclarationDesugarizer < TypeDeclarations::Desugarizer
+          def applicable?(sugary_type_declaration)
+            return false if sugary_type_declaration.strict?
+            return false unless sugary_type_declaration.hash?
+            return false unless sugary_type_declaration.all_symbolizable_keys?
+
+            type_symbol = sugary_type_declaration[:type]
+
+            type_symbol.is_a?(::Symbol) && type_symbol == :associative_array &&
+              sugary_type_declaration.key?(:value_type_declaration)
+          end
+
+          def desugarize(sugary_type_declaration)
+            sugary_type_declaration.symbolize_keys!
+
+            sugar = sugary_type_declaration[:value_type_declaration]
+
+            strict = if sugar.is_a?(Types::Type)
+                       sugar.reference_or_declaration_data
+                     else
+                       declaration = sugary_type_declaration.clone_from_part(sugar)
+
+                       if sugary_type_declaration.deep_duped?
+                         declaration.is_deep_duped = true
+                         declaration.is_duped = true
+                       end
+
+                       handler = type_declaration_handler_for(declaration)
+                       handler.desugarize(declaration).declaration_data
+                     end
+
+            sugary_type_declaration[:value_type_declaration] = strict
+
+            sugary_type_declaration
+          end
+
+          def priority
+            Priority::LOW
+          end
+        end
+      end
+    end
+  end
+end

data/projects/type_declarations/src/handlers/extend_associative_array_type_declaration.rb

@@ -5,9 +5,19 @@ module Foobara
     module Handlers
       class ExtendAssociativeArrayTypeDeclaration < ExtendRegisteredTypeDeclaration
         def applicable?(sugary_type_declaration)
-          strictish_type_declaration = desugarize(sugary_type_declaration)
+          strictish_type_declaration = if sugary_type_declaration.strict?
+                                         sugary_type_declaration
+                                       else
+                                         desugarize(sugary_type_declaration.clone)
+                                       end
 
-          strictish_type_declaration.is_a?(::Hash) && strictish_type_declaration[:type] == :associative_array
+          if strictish_type_declaration.hash? && strictish_type_declaration[:type] == :associative_array
+            unless strictish_type_declaration.equal?(sugary_type_declaration)
+              sugary_type_declaration.assign(strictish_type_declaration)
+            end
+
+            true
+          end
         end
 
         # TODO: do we really need this? Isn't this the default?

data/projects/type_declarations/src/handlers/extend_attributes_type_declaration/dsl_desugarizer.rb

@@ -6,7 +6,7 @@ module Foobara
       class ExtendAttributesTypeDeclaration < ExtendAssociativeArrayTypeDeclaration
         class DslDesugarizer < TypeDeclarations::Desugarizer
           def applicable?(sugary_type_declaration)
-            sugary_type_declaration.is_a?(::Proc)
+            sugary_type_declaration.proc?
           end
 
           def desugarize(block)