dm-core 1.1.0 → 1.2.0.rc1

data/lib/dm-core/adapters/abstract_adapter.rb

@@ -208,8 +208,7 @@ module DataMapper
       #
       # @api semipublic
       def attributes_as_fields(attributes)
-        pairs = attributes.map { |property, value| [ property.field, property.dump(value) ] }
-        DataMapper::Ext::Array.to_hash(pairs)
+        Hash[ attributes.map { |property, value| [ property.field, property.dump(value) ] } ]
       end
 
       private

data/lib/dm-core/associations/many_to_many.rb

@@ -124,6 +124,14 @@ module DataMapper
           @links.freeze
         end
 
+        # Initialize the chain for "many to many" relationships
+        #
+        # @api public
+        def finalize
+          through
+          via
+        end
+
         # @api private
         def source_scope(source)
           { through.inverse => source }
@@ -248,15 +256,13 @@ module DataMapper
           target_key.valid?(source_key.get(source))
         end
 
-        # @api semipublic
         chainable do
+          # @api semipublic
           def many_to_one_options
             { :parent_key => target_key.map { |property| property.name } }
           end
-        end
 
-        # @api semipublic
-        chainable do
+          # @api semipublic
           def one_to_many_options
             { :parent_key => source_key.map { |property| property.name } }
           end
@@ -359,7 +365,7 @@ module DataMapper
           end
 
           each do |resource|
-            resource.persisted_state = Resource::State::Immutable.new(resource)
+            resource.persistence_state = Resource::PersistenceState::Immutable.new(resource)
           end
 
           clear

data/lib/dm-core/associations/many_to_one.rb

@@ -4,7 +4,7 @@ module DataMapper
       # Relationship class with implementation specific
       # to n side of 1 to n association
       class Relationship < Associations::Relationship
-        OPTIONS = superclass::OPTIONS.dup << :required << :key
+        OPTIONS = superclass::OPTIONS.dup << :required << :key << :unique
 
         # @api semipublic
         alias_method :source_repository_name, :child_repository_name
@@ -31,6 +31,11 @@ module DataMapper
           @key
         end
 
+        # @api semipublic
+        def unique?
+          !!@unique
+        end
+
         # @deprecated
         def nullable?
           raise "#{self.class}#nullable? is deprecated, use #{self.class}#required? instead (#{caller.first})"
@@ -64,6 +69,14 @@ module DataMapper
         # @api semipublic
         alias_method :source_key, :child_key
 
+        # Initialize the foreign key property this "many to one"
+        # relationship uses to persist itself
+        #
+        # @api public
+        def finalize
+          child_key
+        end
+
         # Returns a hash of conditions that scopes query that fetches
         # target object
         #
@@ -193,6 +206,7 @@ module DataMapper
 
           @required      = options.fetch(:required, true)
           @key           = options.fetch(:key,      false)
+          @unique        = options.fetch(:unique,   false)
           target_model ||= DataMapper::Inflector.camelize(name)
           options        = { :min => @required ? 1 : 0, :max => 1 }.update(options)
           super
@@ -248,7 +262,8 @@ module DataMapper
           options = DataMapper::Ext::Hash.only(target_property.options, :length, :precision, :scale).update(
             :index    => name,
             :required => required?,
-            :key      => key?
+            :key      => key?,
+            :unique   => @unique
           )
 
           if target_property.primitive == Integer

data/lib/dm-core/associations/one_to_many.rb

@@ -100,6 +100,22 @@ module DataMapper
           end
         end
 
+        # initialize the inverse "many to one" relationships explicitly before
+        # initializing other relationships. This makes sure that foreign key
+        # properties always appear in the order they were declared.
+        #
+        # @api public
+        def finalize
+          child_model.relationships.each do |relationship|
+            # TODO: should this check #inverse?
+            #   relationship.child_key if inverse?(relationship)
+            if relationship.kind_of?(Associations::ManyToOne::Relationship)
+              relationship.finalize
+            end
+          end
+          inverse.finalize
+        end
+
         # @api semipublic
         def default_for(source)
           collection_for(source).replace(Array(super))

data/lib/dm-core/backwards.rb

@@ -0,0 +1,13 @@
+require "dm-core/support/deprecate"
+
+module DataMapper
+  module Resource
+    extend Deprecate
+
+    deprecate :persisted_state,   :persistence_state
+    deprecate :persisted_state=,  :persistence_state=
+    deprecate :persisted_state?,  :persistence_state?
+
+  end # module Resource
+
+end # module DataMapper

data/lib/dm-core/collection.rb

@@ -919,7 +919,7 @@ module DataMapper
         end
 
         each do |resource|
-          resource.persisted_state = Resource::State::Immutable.new(resource)
+          resource.persistence_state = Resource::PersistenceState::Immutable.new(resource)
         end
 
         clear

data/lib/dm-core/model.rb

@@ -1,14 +1,10 @@
-# TODO: add Model#create!, Model#update, Model#update!, Model#destroy and Model#destroy!
-
-# TODO: DRY up raise_on_save_failure with attr_accessor_with_default
-# once AS branch is merged in
-
 module DataMapper
   module Model
-    extend Chainable
-
     include Enumerable
 
+    WRITER_METHOD_REGEXP   = /=\z/.freeze
+    INVALID_WRITER_METHODS = %w[ == != === []= taguri= attributes= collection= persistence_state= raise_on_save_failure= ].to_set.freeze
+
     # Creates a new Model class with its constant already set
     #
     # If a block is passed, it will be eval'd in the context of the new Model
@@ -132,6 +128,19 @@ module DataMapper
       @raise_on_save_failure = raise_on_save_failure
     end
 
+    # Finish model setup and verify it is valid
+    #
+    # @return [undefined]
+    #
+    # @api public
+    def finalize
+      finalize_relationships
+      finalize_allowed_writer_methods
+      assert_valid_name
+      assert_valid_properties
+      assert_valid_key
+    end
+
     # Appends a module for inclusion into the model class after Resource.
     #
     # This is a useful way to extend Resource while still retaining a
@@ -211,15 +220,13 @@ module DataMapper
     end
 
     # @api private
-    chainable do
-      def inherited(descendant)
-        descendants << descendant
-
-        descendant.instance_variable_set(:@valid,         false)
-        descendant.instance_variable_set(:@base_model,    base_model)
-        descendant.instance_variable_set(:@storage_names, @storage_names.dup)
-        descendant.instance_variable_set(:@default_order, @default_order.dup)
-      end
+    def inherited(descendant)
+      descendants << descendant
+
+      descendant.instance_variable_set(:@valid,         false)
+      descendant.instance_variable_set(:@base_model,    base_model)
+      descendant.instance_variable_set(:@storage_names, @storage_names.dup)
+      descendant.instance_variable_set(:@default_order, @default_order.dup)
     end
 
     # Gets the name of the storage receptacle for this resource in the given
@@ -564,8 +571,7 @@ module DataMapper
       discriminator   = properties(repository_name).discriminator
       no_reload       = !query.reload?
 
-      field_map = fields.map { |property| [ property, property.field ] }
-      field_map = DataMapper::Ext::Array.to_hash(field_map)
+      field_map = Hash[ fields.map { |property| [ property, property.field ] } ]
 
       records.map do |record|
         identity_map = nil
@@ -621,13 +627,13 @@ module DataMapper
         resource.instance_variable_set(:@_repository, repository)
 
         if identity_map
-          resource.persisted_state = Resource::State::Clean.new(resource) unless resource.persisted_state?
+          resource.persistence_state = Resource::PersistenceState::Clean.new(resource) unless resource.persistence_state?
 
           # defer setting the IdentityMap so second level caches can
           # record the state of the resource after loaded
           identity_map[key_values] = resource
         else
-          resource.persisted_state = Resource::State::Immutable.new(resource)
+          resource.persistence_state = Resource::PersistenceState::Immutable.new(resource)
         end
 
         resource
@@ -637,6 +643,13 @@ module DataMapper
     # @api semipublic
     attr_reader :base_model
 
+    # The list of writer methods that can be mass-assigned to in #attributes=
+    #
+    # @return [Set]
+    #
+    # @api private
+    attr_reader :allowed_writer_methods
+
     # @api semipublic
     def default_repository_name
       Repository.default_name
@@ -760,32 +773,32 @@ module DataMapper
       end
     end
 
+    # Initialize all foreign key properties established by relationships
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def finalize_relationships
+      relationships(repository_name).each { |relationship| relationship.finalize }
+    end
+
+    # Initialize the list of allowed writer methods
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def finalize_allowed_writer_methods
+      @allowed_writer_methods  = public_instance_methods.map { |method| method.to_s }.grep(WRITER_METHOD_REGEXP).to_set
+      @allowed_writer_methods -= INVALID_WRITER_METHODS
+      @allowed_writer_methods.freeze
+    end
+
     # @api private
     # TODO: Remove this once appropriate warnings can be added.
     def assert_valid(force = false) # :nodoc:
       return if @valid && !force
       @valid = true
-
-      name            = self.name
-      repository_name = self.repository_name
-
-      if properties(repository_name).empty? &&
-        !relationships(repository_name).any? { |(relationship_name, relationship)| relationship.kind_of?(Associations::ManyToOne::Relationship) }
-        raise IncompleteModelError, "#{name} must have at least one property or many to one relationship to be valid"
-      end
-
-      if key(repository_name).empty?
-        raise IncompleteModelError, "#{name} must have a key to be valid"
-      end
-
-      # initialize join models and target keys
-      @relationships.values.each do |relationships|
-        relationships.each do |relationship|
-          relationship.child_key
-          relationship.through if relationship.respond_to?(:through)
-          relationship.via     if relationship.respond_to?(:via)
-        end
-      end
+      finalize
     end
 
     # Raises an exception if #get receives the wrong number of arguments
@@ -807,5 +820,50 @@ module DataMapper
         raise ArgumentError, "The number of arguments for the key is invalid, expected #{expected_key_size} but was #{actual_key_size}"
       end
     end
+
+    # Test if the model name is valid
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def assert_valid_name
+      if name.to_s.strip.empty?
+        raise IncompleteModelError, "#{inspect} must have a name"
+      end
+    end
+
+    # Test if the model has properties
+    #
+    # A model may also be valid if it has at least one m:1 relationships which
+    # will add inferred foreign key properties.
+    #
+    # @return [undefined]
+    #
+    # @raise [IncompleteModelError]
+    #   raised if the model has no properties
+    #
+    # @api private
+    def assert_valid_properties
+      repository_name = self.repository_name
+      if properties(repository_name).empty? &&
+        !relationships(repository_name).any? { |relationship| relationship.kind_of?(Associations::ManyToOne::Relationship) }
+        raise IncompleteModelError, "#{name} must have at least one property or many to one relationship to be valid"
+      end
+    end
+
+    # Test if the model has a valid key
+    #
+    # @return [undefined]
+    #
+    # @raise [IncompleteModelError]
+    #   raised if the model does not have a valid key
+    #
+    # @api private
+    def assert_valid_key
+      if key(repository_name).empty?
+        raise IncompleteModelError, "#{name} must have a key to be valid"
+      end
+    end
+
   end # module Model
 end # module DataMapper

data/lib/dm-core/model/property.rb

@@ -6,25 +6,22 @@ module DataMapper
     module Property
       Model.append_extensions self, DataMapper::Property::Lookup
 
-      extend Chainable
-
       def self.extended(model)
         model.instance_variable_set(:@properties,               {})
         model.instance_variable_set(:@field_naming_conventions, {})
       end
 
-      chainable do
-        def inherited(model)
-          model.instance_variable_set(:@properties,               {})
-          model.instance_variable_set(:@field_naming_conventions, @field_naming_conventions.dup)
 
-          @properties.each do |repository_name, properties|
-            model_properties = model.properties(repository_name)
-            properties.each { |property| model_properties << property }
-          end
+      def inherited(model)
+        model.instance_variable_set(:@properties,               {})
+        model.instance_variable_set(:@field_naming_conventions, @field_naming_conventions.dup)
 
-          super
+        @properties.each do |repository_name, properties|
+          model_properties = model.properties(repository_name)
+          properties.each { |property| model_properties << property }
         end
+
+        super
       end
 
       # Defines a Property on the Resource
@@ -64,13 +61,16 @@ module DataMapper
 
         # Add property to the other mappings as well if this is for the default
         # repository.
+
         if repository_name == default_repository_name
-          DataMapper::Ext::Hash.except(@properties, default_repository_name).each do |other_repository_name, properties|
+          other_repository_properties = DataMapper::Ext::Hash.except(@properties, default_repository_name)
+
+          other_repository_properties.each do |other_repository_name, properties|
             next if properties.named?(name)
 
             # make sure the property is created within the correct repository scope
             DataMapper.repository(other_repository_name) do
-              properties << klass.new(self, name, options, type)
+              properties << klass.new(self, name, options)
             end
           end
         end
@@ -175,11 +175,10 @@ module DataMapper
 
       # @api private
       def key_conditions(repository, key)
-        conditions = self.key(repository.name).zip(key.nil? ? [] : key)
-        DataMapper::Ext::Array.to_hash(conditions)
+        Hash[ self.key(repository.name).zip(key.nil? ? [] : key) ]
       end
 
-      private
+    private
 
       # Defines the anonymous module that is used to add properties.
       # Using a single module here prevents having a very large number
@@ -207,7 +206,7 @@ module DataMapper
           def #{name}
             return #{instance_variable_name} if defined?(#{instance_variable_name})
             property = properties[#{name.inspect}]
-            #{instance_variable_name} = property ? persisted_state.get(property) : nil
+            #{instance_variable_name} = property ? persistence_state.get(property) : nil
           end
         RUBY
 
@@ -235,21 +234,19 @@ module DataMapper
           #{writer_visibility}
           def #{writer_name}(value)
             property = properties[#{name.inspect}]
-            self.persisted_state = persisted_state.set(property, value)
-            persisted_state.get(property)
+            self.persistence_state = persistence_state.set(property, value)
+            persistence_state.get(property)
           end
         RUBY
       end
 
-      chainable do
-        # @api public
-        def method_missing(method, *args, &block)
-          if property = properties(repository_name)[method]
-            return property
-          end
-
-          super
+      # @api public
+      def method_missing(method, *args, &block)
+        if property = properties(repository_name)[method]
+          return property
         end
+
+        super
       end
     end # module Property
   end # module Model