foobara 0.0.1

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

@@ -0,0 +1,170 @@
+module Foobara
+  class Entity < Model
+    module Concerns
+      module Attributes
+        class UnexpectedPrimaryKeyChangeError < StandardError; end
+
+        include Concern
+
+        def write_attribute_without_callbacks(attribute_name, value)
+          without_callbacks do
+            write_attribute(attribute_name, value)
+          end
+        end
+
+        def write_attribute(attribute_name, value)
+          verify_not_hard_deleted!
+
+          with_changed_attribute_callbacks(attribute_name) do
+            load_if_necessary!(attribute_name)
+
+            attribute_name = attribute_name.to_sym
+
+            if attribute_name == primary_key_attribute
+              if value.nil?
+                # :nocov:
+                raise "Primary key cannot be set to a blank value"
+                # :nocov:
+              end
+
+              if value.is_a?(::String) && value.empty?
+                # :nocov:
+                raise "Primary key cannot be set to a blank value"
+                # :nocov:
+              end
+
+              if value.is_a?(::Symbol) && value.to_s.empty?
+                # :nocov:
+                raise "Primary key cannot be set to a blank value"
+                # :nocov:
+              end
+
+              write_attribute!(attribute_name, value)
+            else
+              attribute_name = attribute_name.to_sym
+              # This is a bit of a problem when creating invalid models from attributes...
+              # feels like we should do the best we can instead of not casting it at all. That is, better to have
+              # an invalid Model instance than a hash when a Model is expected.
+              # How do we go about doing that?
+              outcome = cast_attribute(attribute_name, value)
+              attributes[attribute_name] = outcome.success? ? outcome.result : value
+            end
+          end
+        end
+
+        def write_attribute_without_callbacks!(attribute_name, value)
+          without_callbacks do
+            write_attribute!(attribute_name, value)
+          end
+        end
+
+        def write_attribute!(attribute_name, value)
+          verify_not_hard_deleted!
+
+          with_changed_attribute_callbacks(attribute_name) do
+            load_if_necessary!(attribute_name)
+
+            attribute_name = attribute_name.to_sym
+
+            if attribute_name == primary_key_attribute && primary_key
+              outcome = cast_attribute(attribute_name, value)
+
+              if outcome.success?
+                value = outcome.result
+              end
+
+              if value != primary_key
+                raise UnexpectedPrimaryKeyChangeError,
+                      "Primary key already set to #{primary_key}. Can't change to #{value}. " \
+                      "Use attributes[:#{attribute_name}] = #{value.inspect} " \
+                      "instead if you really want to change the primary key."
+              end
+            end
+
+            attribute_name = attribute_name.to_sym
+            attributes[attribute_name] = cast_attribute!(attribute_name, value)
+          end
+        end
+
+        def write_attributes_without_callbacks(attributes)
+          without_callbacks do
+            write_attributes(attributes)
+          end
+        end
+
+        def write_attributes(attributes)
+          verify_not_hard_deleted!
+
+          with_changed_attribute_callbacks(attributes.keys) do
+            load_if_necessary!(attributes)
+
+            attributes.each_pair do |attribute_name, value|
+              write_attribute_without_callbacks(attribute_name, value)
+            end
+          end
+        end
+
+        def read_attribute(attribute_name)
+          load_if_necessary!(attribute_name)
+          super
+        end
+
+        def read_attribute!(attribute_name)
+          load_if_necessary!(attribute_name)
+          super
+        end
+
+        def with_changed_attribute_callbacks(attribute_names)
+          # TODO: clean up methods to use this flag instead of calling each other
+          if @callbacks_disabled
+            yield
+            return
+          end
+
+          attribute_names = Util.array(attribute_names)
+
+          old_is_dirty = dirty? # TODO: don't bother with this check unless there are relevant callbacks
+          old_is_valid = valid? # TODO: don't bother with this check unless there are relevant callbacks
+
+          old_values = attribute_names.map { |attribute_name| read_attribute(attribute_name) }
+
+          yield
+
+          new_values = attribute_names.map { |attribute_name| read_attribute(attribute_name) }
+
+          attribute_changed = false
+
+          old_values.each.with_index do |old_value, index|
+            new_value = new_values[index]
+
+            if new_value != old_value
+              attribute_changed = true
+              fire(:attribute_changed, attribute_name: attribute_names[index], old_value:, new_value:)
+            end
+          end
+
+          if attribute_changed
+            new_is_dirty = dirty?
+
+            if old_is_dirty != new_is_dirty
+              old_is_dirty ? fire(:undirtied) : fire(:dirtied)
+            end
+
+            new_is_valid = valid?
+
+            if old_is_valid != new_is_valid
+              # TODO: don't bother with this check unless there are relevant callbacks
+              new_is_valid ? fire(:uninvalidated) : fire(:invalidated)
+            end
+          end
+        end
+
+        def values_at(data_path)
+          data_path = DataPath.new(data_path) unless data_path.is_a?(DataPath)
+
+          data_path.values_at(self)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+module Foobara
+  class Entity < Model
+    module Concerns
+      module Callbacks
+        include Concern
+
+        class << self
+          def reset_all
+            Entity.instance_variable_set("@class_callback_registry", nil)
+          end
+        end
+
+        # owner helps with determining the relevant object when running class-registered state transition callbacks
+        attr_accessor :callback_registry
+
+        def initialize(...)
+          self.callback_registry = Callback::Registry::ChainedMultipleAction.new(self.class.class_callback_registry)
+          super
+        end
+
+        # TODO: support passing multiple actions here
+        def fire(action, data = {})
+          callback_registry.runner(action).callback_data(data.merge(record: self, action:)).run
+        end
+
+        def without_callbacks
+          old_callbacks_enabled = @callbacks_disabled
+
+          begin
+            @callbacks_disabled = true
+            yield
+          ensure
+            @callbacks_disabled = old_callbacks_enabled
+          end
+        end
+
+        foobara_delegate :register_callback, to: :callback_registry
+
+        module ClassMethods
+          def class_callback_registry
+            @class_callback_registry ||= begin
+              actions = %i[
+                initialized
+                initialized_built
+                initialized_thunk
+                initialized_loaded
+                initialized_created
+                dirtied
+                undirtied
+                attribute_changed
+                reverted
+                loaded
+                persisted
+                hard_deleted
+                unhard_deleted
+                invalidated
+                uninvalidated
+              ]
+
+              if self == Entity
+                Callback::Registry::MultipleAction.new(actions).tap do |registry|
+                  registry.allowed_types = [:after]
+                end
+              else
+                Callback::Registry::ChainedMultipleAction.new(superclass.class_callback_registry)
+              end
+            end
+          end
+
+          foobara_delegate :register_callback, :possible_actions, to: :class_callback_registry
+        end
+
+        on_include do
+          class_callback_registry.allowed_types.each do |type|
+            [self, singleton_class].each do |target|
+              method_name = "#{type}_any_action"
+
+              target.define_method method_name do |&block|
+                register_callback(type, nil, &block)
+              end
+            end
+
+            possible_actions.each do |action|
+              method_name = "#{type}_#{action}"
+
+              [self, singleton_class].each do |target|
+                target.define_method method_name do |&block|
+                  register_callback(type, action, &block)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+module Foobara
+  class Entity < Model
+    class NoCurrentTransactionError < StandardError; end
+
+    module Concerns
+      module Initialization
+        include Concern
+
+        module ClassMethods
+          def can_be_created_through_casting?
+            true
+          end
+
+          def build(attributes)
+            record = __private_new__
+            record.build(attributes)
+            # TODO: rename to something like "detached"
+            record.is_built = true
+
+            record.fire(:initialized)
+            record.fire(:initialized_built)
+
+            record
+          end
+
+          def thunk(record_id)
+            record_id = primary_key_type.process_value!(record_id)
+
+            # TODO: is this possible?
+            if record_id.nil?
+              # :nocov:
+              raise ArgumentError, "Primary key cannot be blank"
+              # :nocov:
+            end
+
+            # check if tracked already...
+            record = current_transaction_table.find_tracked(record_id)
+
+            return record if record
+
+            record = __private_new__
+            record.is_persisted = true
+            record.write_attributes_without_callbacks(primary_key_attribute => record_id)
+
+            record.fire(:initialized)
+            record.fire(:initialized_thunk)
+
+            record
+          end
+
+          def loaded(attributes)
+            attributes = attributes_type.process_value!(attributes)
+
+            record_id = attributes[primary_key_attribute]
+
+            record = current_transaction_table.find_tracked(record_id)
+
+            if record
+              # :nocov:
+              raise "Already loaded for #{attributes}. Bug maybe?"
+              # :nocov:
+            end
+
+            record = __private_new__
+
+            record.successfully_loaded(attributes)
+
+            unless record.primary_key
+              # :nocov:
+              raise "Expected primary key #{primary_key_attribute} to be present!"
+              # :nocov:
+            end
+
+            record.fire(:initialized)
+            record.fire(:initialized_loaded)
+
+            record
+          end
+
+          def create(attributes = {})
+            record = __private_new__
+            record.is_created = true
+
+            defaults = attributes_type.declaration_data[:defaults]
+            if defaults && !defaults.empty?
+              record.write_attributes_without_callbacks(defaults)
+            end
+
+            record.write_attributes_without_callbacks(attributes)
+
+            # TODO: delete :initialized if unused
+            record.fire(:initialized)
+            record.fire(:initialized_created)
+
+            record
+          end
+        end
+
+        def successfully_loaded(attributes)
+          if hard_deleted?
+            # :nocov:
+            raise "Not expecting to load a hard deleted record"
+            # :nocov:
+          end
+
+          # TODO: why would we proceed if this is the case? Maybe raise?
+          already_loaded = loaded?
+
+          self.is_persisted = true
+          self.is_loaded = true
+
+          write_attributes_without_callbacks(attributes)
+
+          save_persisted_attributes
+
+          unless already_loaded
+            fire(:loaded)
+          end
+        end
+
+        def build(attributes = {})
+          write_attributes_without_callbacks(attributes)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,142 @@
+module Foobara
+  class Entity < Model
+    module Concerns
+      module Persistence
+        class CannotUpdateHardDeletedRecordError < StandardError; end
+        class UnknownIfPersisted < StandardError; end
+
+        include Concern
+
+        attr_accessor :is_loaded, :is_persisted, :is_hard_deleted, :is_built, :is_created, :persisted_attributes
+
+        module ClassMethods
+          def entity_base
+            @entity_base ||= Foobara::Persistence.base_for_entity_class_name(full_entity_name)
+          end
+        end
+
+        def hard_delete!
+          hard_delete_without_callbacks!
+          fire(:hard_deleted)
+        end
+
+        def hard_delete_without_callbacks!
+          @is_hard_deleted = true
+        end
+
+        def save_persisted_attributes
+          self.persisted_attributes = to_persisted_attributes(attributes)
+        end
+
+        def to_persisted_attributes(object)
+          case object
+          when ::Hash
+            object.to_h do |k, v|
+              [to_persisted_attributes(k), to_persisted_attributes(v)]
+            end
+          when ::Array
+            object.map { |v| to_persisted_attributes(v) }
+          else
+            object.dup
+          end
+        end
+
+        # Persisted means it is currently written to the database
+        def persisted?
+          is_persisted
+        end
+
+        def created?
+          is_created
+        end
+
+        def loaded?
+          is_loaded
+        end
+
+        # TODO: rename, maybe #detatched? or something?
+        def built?
+          is_built
+        end
+
+        def load_if_necessary!(attribute_name_or_attributes)
+          return if built?
+          return if loaded?
+          return unless persisted?
+
+          attribute_name = if attribute_name_or_attributes.is_a?(::Hash)
+                             if attribute_name_or_attributes.keys.size == 1
+                               attribute_name_or_attributes.keys.first.to_sym
+                             end
+                           elsif attribute_name_or_attributes
+                             attribute_name_or_attributes.to_sym
+                           end
+
+          # TODO: are these symbols or not?
+          return if attribute_name == primary_key_attribute.to_sym
+
+          # TODO: how to get this out of here??
+          transaction = Foobara::Persistence::EntityBase::Transaction.open_transaction_for(self)
+
+          unless transaction
+            # :nocov:
+            raise NoCurrentTransactionError, "Trying to load a #{entity_name} outside of a transaction."
+            # :nocov:
+          end
+
+          unless transaction.loading?(self)
+            transaction.load(self)
+          end
+        end
+
+        def verify_not_hard_deleted!
+          if hard_deleted?
+            raise CannotUpdateHardDeletedRecordError,
+                  "Cannot make further updates to this record because it has been hard deleted"
+          end
+        end
+
+        def unhard_delete!(skip_callbacks: false)
+          self.is_hard_deleted = false
+
+          unless skip_callbacks
+            fire(:unhard_deleted)
+          end
+        end
+
+        def restore!(skip_callbacks: false)
+          if persisted?
+            if hard_deleted?
+              unhard_delete!(skip_callbacks:)
+            end
+
+            if loaded?
+              if skip_callbacks
+                write_attributes_without_callbacks(persisted_attributes)
+              else
+                write_attributes(persisted_attributes)
+              end
+            end
+          else
+            hard_delete!
+          end
+        end
+
+        def restore_without_callbacks!
+          restore!(skip_callbacks: true)
+        end
+
+        def dirty?
+          return true unless persisted?
+          return false unless loaded?
+
+          persisted_attributes != to_persisted_attributes(attributes)
+        end
+
+        def hard_deleted?
+          @is_hard_deleted
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Foobara
+  class Entity < Model
+    module Concerns
+      module PrimaryKey
+        include Concern
+
+        foobara_delegate :primary_key_attribute, to: :class
+
+        module ClassMethods
+          def primary_key(attribute_name)
+            if primary_key_attribute
+              # :nocov:
+              raise "Primary key already set to #{primary_key_attribute}"
+              # :nocov:
+            end
+
+            if attribute_name.nil? || attribute_name.empty?
+              # :nocov:
+              raise ArgumentError, "Primary key can't be blank"
+              # :nocov:
+            end
+
+            @primary_key_attribute = attribute_name.to_sym
+
+            set_model_type
+          end
+
+          def primary_key_attribute
+            return @primary_key_attribute if @primary_key_attribute
+
+            unless superclass == Entity
+              @primary_key_attribute = superclass.primary_key_attribute
+            end
+          end
+        end
+
+        def primary_key
+          read_attribute(primary_key_attribute)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+module Foobara
+  class Entity < Model
+    module Concerns
+      module Queries
+        include Concern
+
+        module ClassMethods
+          def all(&)
+            current_transaction_table.all(&)
+          end
+
+          def first
+            # TODO: don't all queries need to do this???
+            Foobara::Namespace.use entity_type do
+              current_transaction_table.first
+            end
+          end
+
+          def find_by_attribute(attribute_name, value)
+            current_transaction_table.find_by_attribute(attribute_name, value)
+          end
+
+          def find_all_by_attribute(attribute_name, value)
+            current_transaction_table.find_all_by_attribute(attribute_name, value)
+          end
+
+          def find_by_attribute_containing(attribute_name, value)
+            current_transaction_table.find_by_attribute_containing(attribute_name, value)
+          end
+
+          def find_all_by_attribute_containing_any_of(attribute_name, values)
+            current_transaction_table.find_all_by_attribute_containing_any_of(attribute_name, values)
+          end
+
+          def find_all_by_attribute_any_of(attribute_name, values)
+            current_transaction_table.find_all_by_attribute_any_of(attribute_name, values)
+          end
+
+          def find_by(attributes)
+            current_transaction_table.find_by(attributes)
+          end
+
+          def find_many_by(attributes)
+            current_transaction_table.find_many_by(attributes)
+          end
+
+          def load(record)
+            if !record.is_a?(Foobara::Entity) || !record.loaded?
+              current_transaction_table.load(record)
+            end
+          rescue ::Foobara::Persistence::EntityAttributesCrudDriver::Table::CannotFindError
+            primary_key = if record.is_a?(Foobara::Entity)
+                            record.primary_key
+                          else
+                            record
+                          end
+
+            raise NotFoundError.new(primary_key, entity_class: self)
+          end
+
+          def load_aggregate(record_or_record_id)
+            record = if record_or_record_id.is_a?(Entity)
+                       record_or_record_id
+                     else
+                       thunk(record_or_record_id)
+                     end
+
+            current_transaction.load_aggregate(record)
+          end
+
+          def load_many(*record_ids)
+            if record_ids.size == 1 && record_ids.first.is_a?(::Array)
+              record_ids = record_ids.first
+            end
+
+            current_transaction_table.load_many(record_ids)
+          end
+
+          def all_exist?(record_ids)
+            # TODO: support splat
+            current_transaction_table.all_exist?(record_ids)
+          end
+
+          def exists?(record_id)
+            # TODO: support splat
+            current_transaction_table.exists?(record_id)
+          end
+
+          def count
+            current_transaction_table.count
+          end
+        end
+      end
+    end
+  end
+end