dm-core 0.10.2 → 1.0.0.rc1

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

@@ -0,0 +1,79 @@
+module DataMapper
+  module Resource
+
+    # the state of the resource (abstract)
+    class State
+      attr_reader :resource
+
+      def initialize(resource)
+        @resource = resource
+      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
+
+      def eql?(other)
+        instance_of?(other.class) &&
+        hash == other.hash
+      end
+
+      def ==(other)
+        self.class <=> other.class &&
+        hash == other.hash
+      end
+
+      def hash
+        resource.object_id.hash
+      end
+
+    private
+
+      def model
+        @model ||= resource.model
+      end
+
+      def properties
+        @properties ||= model.properties(repository.name)
+      end
+
+      def relationships
+        @relationships ||= model.relationships(repository.name).values
+      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 reset_original_attributes
+        original_attributes.clear
+      end
+
+    end # class State
+  end # module Resource
+end # module DataMapper

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

@@ -0,0 +1,40 @@
+module DataMapper
+  module Resource
+    class State
+
+      # a persisted/unmodified resource
+      class Clean < Persisted
+        def set(subject, value)
+          if not_modified?(subject, value)
+            self
+          else
+            # assign to persisted_state so that if Dirty#set calls
+            # a Relationship#set, which modifies a Property, the same
+            # Dirty state instance will be reused.
+            state = resource.persisted_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 State
+  end # module Resource
+end # module DataMapper

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

@@ -0,0 +1,30 @@
+module DataMapper
+  module Resource
+    class State
+
+      # 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 State
+  end # module Resource
+end # module DataMapper

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

@@ -0,0 +1,86 @@
+module DataMapper
+  module Resource
+    class State
+
+      # 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
+          update_resource
+          reset_original_attributes
+          reset_resource_key
+          add_to_identity_map
+          Clean.new(resource)
+        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
+          else
+            # track the original value
+            original_attributes[subject] = get(subject)
+          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
+
+      end # class Dirty
+    end # class State
+  end # module Resource
+end # module DataMapper

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

@@ -0,0 +1,34 @@
+module DataMapper
+  module Resource
+    class State
+
+      # a not-persisted/unmodifiable resource
+      class Immutable < State
+        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 State
+  end # module Resource
+end # module DataMapper

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

@@ -0,0 +1,29 @@
+module DataMapper
+  module Resource
+    class State
+
+      # a persisted resource (abstract)
+      class Persisted < State
+        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 State
+  end # module Resource
+end # module DataMapper

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

@@ -0,0 +1,70 @@
+module DataMapper
+  module Resource
+    class State
+
+      # a not-persisted/modifiable resource
+      class Transient < State
+        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_default_values
+          create_resource
+          set_repository
+          reset_original_attributes
+          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
+
+      end # class Transient
+    end # class State
+  end # module Resource
+end # module DataMapper

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

@@ -0,0 +1,52 @@
+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)
+
+              # 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

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

@@ -0,0 +1,20 @@
+module DataMapper
+  module Spec
+    module CollectionHelpers
+      module GroupMethods
+        def self.extended(base)
+          base.class_inheritable_accessor :loaded
+          base.loaded = false
+        end
+
+        def should_not_be_a_kicker(ivar = :@articles)
+          unless loaded
+            it 'should not be a kicker' do
+              instance_variable_get(ivar).should_not be_loaded
+            end
+          end
+        end
+      end
+    end
+  end
+end