ardm-core 1.2.1

data/lib/dm-core/resource/persistence_state.rb

@@ -0,0 +1,75 @@
+module DataMapper
+  module Resource
+
+    # the state of the resource (abstract)
+    class PersistenceState
+      extend Equalizer
+
+      equalize :resource
+
+      attr_reader :resource
+
+      def initialize(resource)
+        @resource = resource
+        @model    = resource.model
+      end
+
+      def get(subject, *args)
+        subject.get(resource, *args)
+      end
+
+      def set(subject, value)
+        subject.set(resource, value)
+        self
+      end
+
+      def delete
+        raise NotImplementedError, "#{self.class}#delete should be implemented"
+      end
+
+      def commit
+        raise NotImplementedError, "#{self.class}#commit should be implemented"
+      end
+
+      def rollback
+        raise NotImplementedError, "#{self.class}#rollback should be implemented"
+      end
+
+    private
+
+      attr_reader :model
+
+      def properties
+        @properties ||= model.properties(repository.name)
+      end
+
+      def relationships
+        @relationships ||= model.relationships(repository.name)
+      end
+
+      def identity_map
+        @identity_map ||= repository.identity_map(model)
+      end
+
+      def remove_from_identity_map
+        identity_map.delete(resource.key)
+      end
+
+      def add_to_identity_map
+        identity_map[resource.key] = resource
+      end
+
+      def set_child_keys
+        relationships.each do |relationship|
+          set_child_key(relationship)
+        end
+      end
+
+      def set_child_key(relationship)
+        return unless relationship.loaded?(resource) && relationship.respond_to?(:resource_for)
+        set(relationship, get(relationship))
+      end
+
+    end # class PersistenceState
+  end # module Resource
+end # module DataMapper

data/lib/dm-core/resource/persistence_state/clean.rb

@@ -0,0 +1,40 @@
+module DataMapper
+  module Resource
+    class PersistenceState
+
+      # a persisted/unmodified resource
+      class Clean < Persisted
+        def set(subject, value)
+          if not_modified?(subject, value)
+            self
+          else
+            # assign to persistence_state so that if Dirty#set calls
+            # a Relationship#set, which modifies a Property, the same
+            # Dirty state instance will be reused.
+            state = resource.persistence_state = Dirty.new(resource)
+            state.set(subject, value)
+          end
+        end
+
+        def delete
+          Deleted.new(resource)
+        end
+
+        def commit
+          self
+        end
+
+        def rollback
+          self
+        end
+
+      private
+
+        def not_modified?(subject, value)
+          subject.loaded?(resource) && subject.get!(resource).eql?(value)
+        end
+
+      end # class Clean
+    end # class PersistenceState
+  end # module Resource
+end # module DataMapper

data/lib/dm-core/resource/persistence_state/deleted.rb

@@ -0,0 +1,30 @@
+module DataMapper
+  module Resource
+    class PersistenceState
+
+      # a persisted/deleted resource
+      class Deleted < Persisted
+        def set(subject, value)
+          raise ImmutableDeletedError, 'Deleted resource cannot be modified'
+        end
+
+        def delete
+          self
+        end
+
+        def commit
+          delete_resource
+          remove_from_identity_map
+          Immutable.new(resource)
+        end
+
+      private
+
+        def delete_resource
+          repository.delete(collection_for_self)
+        end
+
+      end # class Deleted
+    end # class PersistenceState
+  end # module Resource
+end # module DataMapper

data/lib/dm-core/resource/persistence_state/dirty.rb

@@ -0,0 +1,96 @@
+module DataMapper
+  module Resource
+    class PersistenceState
+
+      # a persisted/dirty resource
+      class Dirty < Persisted
+        def set(subject, value)
+          track(subject, value)
+          super
+          original_attributes.empty? ? Clean.new(resource) : self
+        end
+
+        def delete
+          reset_resource
+          Deleted.new(resource)
+        end
+
+        def commit
+          remove_from_identity_map
+          set_child_keys
+          return self unless valid_attributes?
+          update_resource
+          reset_original_attributes
+          reset_resource_key
+          Clean.new(resource)
+        ensure
+          add_to_identity_map
+        end
+
+        def rollback
+          reset_resource
+          Clean.new(resource)
+        end
+
+        def original_attributes
+          @original_attributes ||= {}
+        end
+
+      private
+
+        def track(subject, value)
+          if original_attributes.key?(subject)
+            # stop tracking if the new value is the same as the original
+            if original_attributes[subject].eql?(value)
+              original_attributes.delete(subject)
+            end
+          elsif !value.eql?(original = get(subject))
+            # track the original value
+            original_attributes[subject] = original
+          end
+        end
+
+        def update_resource
+          repository.update(resource.dirty_attributes, collection_for_self)
+        end
+
+        def reset_resource
+          reset_resource_properties
+          reset_resource_relationships
+        end
+
+        def reset_resource_key
+          resource.instance_eval { remove_instance_variable(:@_key) }
+        end
+
+        def reset_resource_properties
+          # delete every original attribute after resetting the resource
+          original_attributes.delete_if do |property, value|
+            property.set!(resource, value)
+            true
+          end
+        end
+
+        def reset_resource_relationships
+          relationships.each do |relationship|
+            next unless relationship.loaded?(resource)
+            # TODO: consider a method in Relationship that can reset the relationship
+            resource.instance_eval { remove_instance_variable(relationship.instance_variable_name) }
+          end
+        end
+
+        def reset_original_attributes
+          original_attributes.clear
+        end
+
+        def valid_attributes?
+          original_attributes.each_key do |property|
+            return false if property.kind_of?(Property) && !property.valid?(property.get!(resource))
+          end
+          true
+        end
+
+      end # class Dirty
+    end # class PersistenceState
+  end # module Resource
+end # module DataMapper

data/lib/dm-core/resource/persistence_state/immutable.rb

@@ -0,0 +1,34 @@
+module DataMapper
+  module Resource
+    class PersistenceState
+
+      # a not-persisted/unmodifiable resource
+      class Immutable < PersistenceState
+        def get(subject, *args)
+          unless subject.loaded?(resource) || subject.kind_of?(Associations::Relationship)
+            raise ImmutableError, 'Immutable resource cannot be lazy loaded'
+          end
+
+          super
+        end
+
+        def set(subject, value)
+          raise ImmutableError, 'Immutable resource cannot be modified'
+        end
+
+        def delete
+          raise ImmutableError, 'Immutable resource cannot be deleted'
+        end
+
+        def commit
+          self
+        end
+
+        def rollback
+          self
+        end
+
+      end # class Immutable
+    end # class PersistenceState
+  end # module Resource
+end # module DataMapper

data/lib/dm-core/resource/persistence_state/persisted.rb

@@ -0,0 +1,29 @@
+module DataMapper
+  module Resource
+    class PersistenceState
+
+      # a persisted resource (abstract)
+      class Persisted < PersistenceState
+        def get(subject, *args)
+          lazy_load(subject)
+          super
+        end
+
+      private
+
+        def repository
+          @repository ||= resource.instance_variable_get(:@_repository)
+        end
+
+        def collection_for_self
+          @collection_for_self ||= resource.collection_for_self
+        end
+
+        def lazy_load(subject)
+          subject.lazy_load(resource)
+        end
+
+      end # class Persisted
+    end # class PersistenceState
+  end # module Resource
+end # module DataMapper

data/lib/dm-core/resource/persistence_state/transient.rb

@@ -0,0 +1,78 @@
+module DataMapper
+  module Resource
+    class PersistenceState
+
+      # a not-persisted/modifiable resource
+      class Transient < PersistenceState
+        def get(subject, *args)
+          set_default_value(subject)
+          super
+        end
+
+        def set(subject, value)
+          track(subject)
+          super
+        end
+
+        def delete
+          self
+        end
+
+        def commit
+          set_child_keys
+          set_default_values
+          return self unless valid_attributes?
+          create_resource
+          set_repository
+          add_to_identity_map
+          Clean.new(resource)
+        end
+
+        def rollback
+          self
+        end
+
+        def original_attributes
+          @original_attributes ||= {}
+        end
+
+      private
+
+        def repository
+          @repository ||= model.repository
+        end
+
+        def set_default_values
+          (properties | relationships).each do |subject|
+            set_default_value(subject)
+          end
+        end
+
+        def set_default_value(subject)
+          return if subject.loaded?(resource) || !subject.default?
+          set(subject, subject.default_for(resource))
+        end
+
+        def track(subject)
+          original_attributes[subject] = nil
+        end
+
+        def create_resource
+          repository.create([ resource ])
+        end
+
+        def set_repository
+          resource.instance_variable_set(:@_repository, repository)
+        end
+
+        def valid_attributes?
+          properties.all? do |property|
+            value = get(property)
+            property.serial? && value.nil? || property.valid?(value)
+          end
+        end
+
+      end # class Transient
+    end # class PersistenceState
+  end # module Resource
+end # module DataMapper

data/lib/dm-core/spec/lib/adapter_helpers.rb

@@ -0,0 +1,54 @@
+module DataMapper
+  module Spec
+    module Adapters
+
+      module Helpers
+
+        def supported_by(*adapters, &block)
+          adapters = adapters.map { |adapter| adapter.to_sym }
+          adapter  = DataMapper::Spec.adapter_name.to_sym
+          if adapters.include?(:all) || adapters.include?(adapter)
+            describe_adapter(:default, &block)
+          end
+        end
+
+        def with_alternate_adapter(&block)
+          describe_adapter(:alternate, &block)
+        end
+
+        def describe_adapter(kind, &block)
+          describe("with #{kind} adapter") do
+
+            before :all do
+              # store these in instance vars for the shared adapter specs
+              @adapter    = DataMapper::Spec.adapter(kind)
+              @repository = DataMapper.repository(@adapter.name)
+
+              @repository.scope { DataMapper.finalize }
+
+              # create all tables and constraints before each spec
+              if @repository.respond_to?(:auto_migrate!)
+                @repository.auto_migrate!
+              end
+            end
+
+            after :all do
+              # remove all tables and constraints after each spec
+              if @repository.respond_to?(:auto_migrate_down!, true)
+                @repository.send(:auto_migrate_down!, @repository.name)
+              end
+              # TODO consider proper automigrate functionality
+              if @adapter.respond_to?(:reset)
+                @adapter.reset
+              end
+            end
+
+            instance_eval(&block)
+          end
+        end
+
+      end
+
+    end
+  end
+end