sbf-dm-core 1.3.0.beta

data/lib/dm-core/relationship_set.rb

@@ -0,0 +1,69 @@
+module DataMapper
+  # A {SubjectSet} that keeps track of relationships defined in a {Model}
+  #
+  class RelationshipSet < SubjectSet
+    # A list of all relationships in this set
+    #
+    # @deprecated use DataMapper::RelationshipSet#each or DataMapper::RelationshipSet#to_a instead
+    #
+    # @return [Array]
+    #    a list of all relationships in the set
+    #
+    # @api semipublic
+    def values
+      warn "#{self.class}#values is deprecated. Use #{self.class}#each or #{self.class}#to_a instead: #{caller.first}"
+      to_a
+    end
+
+    # A list of all relationships in this set
+    #
+    # @deprecated use DataMapper::RelationshipSet#each instead
+    #
+    # @yield [DataMapper::Associations::Relationship]
+    #    all relationships in the set
+    #
+    # @yieldparam [DataMapper::Associations::Relationship] relationship
+    #    a relationship in the set
+    #
+    # @return [RelationshipSet] self
+    #
+    # @api semipublic
+    def each_value(&block)
+      warn "#{self.class}#each_value is deprecated. Use #{self.class}#each instead: #{caller.first}"
+      each(&block)
+      self
+    end
+
+    # Check whether this RelationshipSet includes an entry with the given name
+    #
+    # @deprecated use DataMapper::RelationshipSet#named? instead
+    #
+    # @param [#to_s] name
+    #   the name of the entry to look for
+    #
+    # @return [Boolean]
+    #   true if the set contains a relationship with the given name
+    #
+    # @api semipublic
+    def key?(name)
+      warn "#{self.class}#key? is deprecated. Use #{self.class}#named? instead: #{caller.first}"
+      named?(name)
+    end
+
+    # Check whether this RelationshipSet includes an entry with the given name
+    #
+    # @deprecated use DataMapper::RelationshipSet#named? instead
+    #
+    # @param [#to_s] name
+    #   the name of the entry to look for
+    #
+    # @return [Boolean]
+    #   true if the set contains a relationship with the given name
+    #
+    # @api semipublic
+    def has_key?(name)
+      warn "#{self.class}#has_key? is deprecated. Use #{self.class}#named? instead: #{caller.first}"
+      named?(name)
+    end
+  end
+end

data/lib/dm-core/repository.rb

@@ -0,0 +1,226 @@
+module DataMapper
+  class Repository
+    include DataMapper::Assertions
+    extend Equalizer
+
+    equalize :name
+
+    # Get the list of adapters registered for all Repositories,
+    # keyed by repository name.
+    #
+    #   TODO: create example
+    #
+    # @return [Hash(Symbol => Adapters::AbstractAdapter)]
+    #   the adapters registered for all Repositories
+    #
+    # @api private
+    def self.adapters
+      @adapters ||= {}
+    end
+
+    # Get the stack of current repository contexts
+    #
+    #   TODO: create example
+    #
+    # @return [Array]
+    #   List of Repository contexts for the current Thread
+    #
+    # @api private
+    def self.context
+      Thread.current[:dm_repository_contexts] ||= []
+    end
+
+    # Get the default name of this Repository
+    #
+    #   TODO: create example
+    #
+    # @return [Symbol]
+    #   the default name of this repository
+    #
+    # @api private
+    def self.default_name
+      :default
+    end
+
+    # @api semipublic
+    attr_reader :name
+
+    # @api semipublic
+    alias_method :to_sym, :name
+
+    # Get the adapter for this repository
+    #
+    # Lazy loads adapter setup from registered adapters
+    #
+    #   TODO: create example
+    #
+    # @return [Adapters::AbstractAdapter]
+    #   the adapter for this repository
+    #
+    # @raise [RepositoryNotSetupError]
+    #   if there is no adapter registered for a repository named @name
+    #
+    # @api semipublic
+    def adapter
+      # Make adapter instantiation lazy so we can defer repository setup until it's actually
+      # needed. Do not remove this code.
+      @adapter ||=
+        begin
+          adapters = self.class.adapters
+
+          raise RepositoryNotSetupError, "Adapter not set: #{@name}. Did you forget to setup?" unless adapters.key?(@name)
+
+          adapters[@name]
+        end
+    end
+
+    # Get the identity for a particular model within this repository.
+    #
+    # If one doesn't yet exist, create a new default in-memory IdentityMap
+    # for the requested model.
+    #
+    #   TODO: create example
+    #
+    # @param [Model] model
+    #   Model whose identity map should be returned
+    #
+    # @return [IdentityMap]
+    #   The IdentityMap for model in this Repository
+    #
+    # @api private
+    def identity_map(model)
+      @identity_maps[model.base_model] ||= IdentityMap.new
+    end
+
+    # Executes a block in the scope of this Repository
+    #
+    #   TODO: create example
+    #
+    # @yieldparam [Repository] repository
+    #   yields self within the block
+    #
+    # @yield
+    #   execute block in the scope of this Repository
+    #
+    # @api private
+    def scope
+      context = Repository.context
+
+      context << self
+
+      begin
+        yield self
+      ensure
+        context.pop
+      end
+    end
+
+    # Create a Query or subclass instance for this repository.
+    #
+    # @param [Model] model
+    #   the Model to retrieve results from
+    # @param [Hash] options
+    #   the conditions and scope
+    #
+    # @return [Query]
+    #
+    # @api semipublic
+    def new_query(model, options = {})
+      adapter.new_query(self, model, options)
+    end
+
+    # Create one or more resource instances in this repository.
+    #
+    #   TODO: create example
+    #
+    # @param [Enumerable(Resource)] resources
+    #   The list of resources (model instances) to create
+    #
+    # @return [Integer]
+    #   The number of records that were actually saved into the data-store
+    #
+    # @api semipublic
+    def create(resources)
+      adapter.create(resources)
+    end
+
+    # Retrieve a collection of results of a query
+    #
+    #   TODO: create example
+    #
+    # @param [Query] query
+    #   composition of the query to perform
+    #
+    # @return [Mixed]
+    #   [DataMapper::Resource] result set of the query
+    #   [Array]
+    #
+    # @api semipublic
+    def read(query)
+      return [] unless query.valid?
+
+      query.model.load(adapter.read(query), query)
+    end
+
+    # Update the attributes of one or more resource instances
+    #
+    #   TODO: create example
+    #
+    # @param [Hash(Property => Object)] attributes
+    #   hash of attribute values to set, keyed by Property
+    # @param [Collection] collection
+    #   collection of records to be updated
+    #
+    # @return [Integer]
+    #   the number of records updated
+    #
+    # @api semipublic
+    def update(attributes, collection)
+      return 0 unless collection.query.valid? && attributes.any?
+
+      adapter.update(attributes, collection)
+    end
+
+    # Delete one or more resource instances
+    #
+    #   TODO: create example
+    #
+    # @param [Collection] collection
+    #   collection of records to be deleted
+    #
+    # @return [Integer]
+    #   the number of records deleted
+    #
+    # @api semipublic
+    def delete(collection)
+      return 0 unless collection.query.valid?
+
+      adapter.delete(collection)
+    end
+
+    # Return a human readable representation of the repository
+    #
+    #   TODO: create example
+    #
+    # @return [String]
+    #   human readable representation of the repository
+    #
+    # @api private
+    def inspect
+      "#<#{self.class.name} @name=#{@name}>"
+    end
+
+    # Initializes a new Repository
+    #
+    #   TODO: create example
+    #
+    # @param [Symbol] name
+    #   The name of the Repository
+    #
+    # @api semipublic
+    private def initialize(name)
+      @name          = name.to_sym
+      @identity_maps = {}
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+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
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+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
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+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
+          assert_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
+            original_attributes.delete(subject) if original_attributes[subject].eql?(value)
+          elsif !value.eql?((original = get(subject)))
+            # track the original value
+            original_attributes[subject] = original
+          end
+        end
+
+        private def update_resource
+          repository.update(resource.dirty_attributes, collection_for_self)
+        end
+
+        private def reset_resource
+          reset_resource_properties
+          reset_resource_relationships
+        end
+
+        private def reset_resource_key
+          resource.instance_eval { remove_instance_variable(:@_key) }
+        end
+
+        private 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
+
+        private 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
+
+        private def reset_original_attributes
+          original_attributes.clear
+        end
+
+        private def assert_valid_attributes
+          properties.each do |property|
+            value = property.get! resource
+            property.assert_valid_value(value)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module DataMapper
+  module Resource
+    class PersistenceState
+      # a not-persisted/unmodifiable resource
+      class Immutable < PersistenceState
+        def get(subject, *args)
+          unless subject.loaded?(resource) || subject.is_a?(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
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+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
+
+        private def collection_for_self
+          @collection_for_self ||= resource.collection_for_self
+        end
+
+        private def lazy_load(subject)
+          subject.lazy_load(resource)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+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
+          assert_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
+
+        private def set_default_values
+          (properties | relationships).each do |subject|
+            set_default_value(subject)
+          end
+        end
+
+        private def set_default_value(subject)
+          return if subject.loaded?(resource) || !subject.default?
+
+          default = typecast_default(subject, subject.default_for(resource))
+          set(subject, default)
+        end
+
+        private def typecast_default(subject, default)
+          return default unless subject.respond_to?(:typecast)
+
+          typecasted_default = subject.send(:typecast, default)
+          unless typecasted_default.eql?(default)
+            warn "Automatic typecasting of default property values is deprecated (#{default.inspect} was casted to #{typecasted_default.inspect}). " \
+                 "Specify the correct type for #{resource.class}."
+          end
+          typecasted_default
+        end
+
+        private def track(subject)
+          original_attributes[subject] = nil
+        end
+
+        private def create_resource
+          repository.create([resource])
+        end
+
+        private def set_repository
+          resource.instance_variable_set(:@_repository, repository)
+        end
+
+        private def assert_valid_attributes
+          properties.each do |property|
+            value = get(property)
+            property.assert_valid_value(value) unless property.serial? && value.nil?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+module DataMapper
+  module Resource
+    # the state of the resource (abstract)
+    class PersistenceState
+      extend Equalizer
+
+      equalize :resource
+
+      attr_reader :resource, :model
+
+      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 def properties
+        @properties ||= model.properties(repository&.name)
+      end
+
+      private def relationships
+        @relationships ||= model.relationships(repository&.name)
+      end
+
+      private def identity_map
+        @identity_map ||= repository&.identity_map(model)
+      end
+
+      private def remove_from_identity_map
+        identity_map.delete(resource.key)
+      end
+
+      private def add_to_identity_map
+        identity_map[resource.key] = resource
+      end
+
+      private def set_child_keys
+        relationships.each do |relationship|
+          set_child_key(relationship)
+        end
+      end
+
+      private def set_child_key(relationship)
+        return unless relationship.loaded?(resource) && relationship.respond_to?(:resource_for)
+
+        set(relationship, get(relationship))
+      end
+    end
+  end
+end