dm-core 0.9.5 → 0.9.6

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

@@ -74,25 +74,29 @@ module DataMapper
 
       # @api private
       def get_children(parent, options = {}, finder = :all, *args)
-        bind_values   = parent_key.get(parent)
-        parent_values = bind_values.dup
+        parent_value = parent_key.get(parent)
+        bind_values  = [ parent_value ]
 
         with_repository(child_model) do |r|
           parent_identity_map = parent.repository.identity_map(parent_model)
           child_identity_map  = r.identity_map(child_model)
 
-          query_values = parent_identity_map.keys.flatten
-          query_values.reject! { |k| child_identity_map[[k]] }
+          query_values = parent_identity_map.keys
+          query_values.reject! { |k| child_identity_map[k] }
 
           bind_values = query_values unless query_values.empty?
-          query = child_key.map { |k| [ k, bind_values ] }.to_hash
+          query = child_key.zip(bind_values.transpose).to_hash
 
           collection = child_model.send(finder, *(args.dup << @query.merge(options).merge(query)))
+
           return collection unless collection.kind_of?(Collection) && collection.any?
 
-          grouped_collection = Hash.new { |h,k| h[k] = [] }
+          grouped_collection = {}
           collection.each do |resource|
-            grouped_collection[get_parent(resource, parent)] << resource
+            child_value = child_key.get(resource)
+            parent_obj = parent_identity_map[child_value]
+            grouped_collection[parent_obj] ||= []
+            grouped_collection[parent_obj] << resource
           end
 
           association_accessor = "#{self.name}_association"
@@ -112,14 +116,14 @@ module DataMapper
             parents_children = Collection.new(query)
             children.each { |child| parents_children.send(:add, child) }
 
-            if parent_key.get(parent) == parent_values
+            if parent_key.get(parent) == parent_value
               ret = parents_children
             else
               association.instance_variable_set(:@children, parents_children)
             end
           end
 
-          ret || child_model.send(finder, *(args.dup << @query.merge(options).merge(child_key.zip(parent_values).to_hash)))
+          ret || child_model.send(finder, *(args.dup << @query.merge(options).merge(child_key.zip([ parent_value ]).to_hash)))
         end
       end
 
@@ -129,14 +133,15 @@ module DataMapper
         return nil unless child_value.nitems == child_value.size
 
         with_repository(parent || parent_model) do
-          parent_identity_map = (parent || parent_model).repository.identity_map(parent_model)
-          child_identity_map  = child.repository.identity_map(child_model)
+          parent_identity_map = (parent || parent_model).repository.identity_map(parent_model.base_model)
+          child_identity_map  = child.repository.identity_map(child_model.base_model)
 
           if parent = parent_identity_map[child_value]
             return parent
           end
 
-          children = child_identity_map.values | [child]
+          children = child_identity_map.values
+          children << child unless child_identity_map[child.key]
 
           bind_values = children.map { |c| child_key.get(c) }.uniq
           query_values = bind_values.reject { |k| parent_identity_map[k] }
@@ -151,21 +156,20 @@ module DataMapper
             children.each do |c|
               c.send(association_accessor).instance_variable_set(:@parent, collection.get(*child_key.get(c)))
             end
-          
             child.send(association_accessor).instance_variable_get(:@parent)
           end
         end
       end
 
       # @api private
-      def with_repository(object = nil, &block)
+      def with_repository(object = nil)
         other_model = object.model == child_model ? parent_model : child_model if object.respond_to?(:model)
         other_model = object       == child_model ? parent_model : child_model if object.kind_of?(DataMapper::Resource)
 
         if other_model && other_model.repository == object.repository && object.repository.name != @repository_name
-          object.repository.scope(&block)
+          object.repository.scope { |block_args| yield(*block_args) }
         else
-          repository(@repository_name, &block)
+          repository(@repository_name) { |block_args| yield(*block_args) }
         end
       end
 

data/lib/dm-core/auto_migrations.rb

@@ -59,7 +59,7 @@ module DataMapper
     # REPEAT: THIS IS DESTRUCTIVE
     #
     # @param Symbol repository_name the repository to be migrated
-    def auto_migrate!(repository_name = nil)
+    def auto_migrate!(repository_name = self.repository_name)
       auto_migrate_down!(repository_name)
       auto_migrate_up!(repository_name)
     end
@@ -71,7 +71,8 @@ module DataMapper
     #
     # @param Symbol repository_name the repository to be migrated
     # @api private
-    def auto_migrate_down!(repository_name = nil)
+    def auto_migrate_down!(repository_name = self.repository_name)
+      # repository_name ||= default_repository_name
       if self.superclass != Object
         self.superclass.auto_migrate!(repository_name)
       else
@@ -86,7 +87,7 @@ module DataMapper
     #
     # @param Symbol repository_name the repository to be migrated
     # @api private
-    def auto_migrate_up!(repository_name = nil)
+    def auto_migrate_up!(repository_name = self.repository_name)
       if self.superclass != Object
         self.superclass.auto_migrate!(repository_name)
       else
@@ -101,7 +102,7 @@ module DataMapper
     # preserving data already in the data-store
     #
     # @param Symbol repository_name the repository to be migrated
-    def auto_upgrade!(repository_name = nil)
+    def auto_upgrade!(repository_name = self.repository_name)
       repository(repository_name) do |r|
         r.adapter.upgrade_model_storage(r, self)
       end

data/lib/dm-core/collection.rb

@@ -52,8 +52,9 @@ module DataMapper
     def get(*key)
       key = model.typecast_key(key)
       if loaded?
-        # loop over the collection to find the matching resource
-        detect { |resource| resource.key == key }
+        # find indexed resource (create index first if it does not exist)
+        each {|r| @cache[r.key] = r } if @cache.empty?
+        @cache[key]
       elsif query.limit || query.offset > 0
         # current query is exclusive, find resource within the set
 
@@ -167,7 +168,7 @@ module DataMapper
     end
 
     ##
-    # Simulates Array#at and returns the entrie at that index.
+    # Simulates Array#at and returns the entry at that index.
     # Also accepts negative indexes and appropriate reverses
     # the order of the query
     #
@@ -295,7 +296,7 @@ module DataMapper
     # @see Array#delete
     #
     # @api public
-    def delete(resource, &block)
+    def delete(resource)
       orphan_resource(super)
     end
 
@@ -515,6 +516,7 @@ module DataMapper
 
       @query          = query
       @key_properties = model.key(repository.name)
+      @cache          = {}
 
       super()
 
@@ -533,6 +535,7 @@ module DataMapper
     def relate_resource(resource)
       return unless resource
       resource.collection = self
+      @cache[resource.key] = resource
       resource
     end
 
@@ -540,7 +543,8 @@ module DataMapper
     # @api private
     def orphan_resource(resource)
       return unless resource
-      resource.collection = nil if resource.collection == self
+      resource.collection = nil if resource.collection.object_id == self.object_id
+      @cache.delete(resource.key)
       resource
     end
 
@@ -626,7 +630,7 @@ module DataMapper
 
         query.update(
           :fields => klass.properties(repository.name).defaults,
-          :links  => self.query.links + [ relationship ]
+          :links  => [ relationship ] + self.query.links
         )
 
         klass.all(query, &block)

data/lib/dm-core/dependency_queue.rb

@@ -6,10 +6,11 @@ module DataMapper
   #
   class DependencyQueue
     def initialize
-      @dependencies = Hash.new { |h,k| h[k] = [] }
+      @dependencies = {}
     end
 
     def add(class_name, &callback)
+      @dependencies[class_name] ||= []
       @dependencies[class_name] << callback
       resolve!
     end

data/lib/dm-core/identity_map.rb

@@ -5,7 +5,7 @@ module DataMapper
   class IdentityMap
     # Get a resource from the IdentityMap
     def get(key)
-      @cache[key]
+      @cache[key] || (@second_level_cache && @second_level_cache.get(key))
     end
 
     alias [] get
@@ -27,11 +27,8 @@ module DataMapper
     private
 
     def initialize(second_level_cache = nil)
-      @cache = if @second_level_cache = second_level_cache
-        Hash.new { |h,key| h[key] = @second_level_cache.get(key) }
-      else
-        Hash.new
-      end
+      @cache = {}
+      @second_level_cache = second_level_cache
     end
 
     def cache

data/lib/dm-core/model.rb

@@ -29,15 +29,15 @@ module DataMapper
     end
 
     def self.extended(model)
-      model.instance_variable_set(:@storage_names, Hash.new { |h,k| h[k] = repository(k).adapter.resource_naming_convention.call(model.send(:default_storage_name)) })
-      model.instance_variable_set(:@properties,    Hash.new { |h,k| h[k] = k == Repository.default_name ? PropertySet.new : h[Repository.default_name].dup })
-      model.instance_variable_set(:@field_naming_conventions, Hash.new { |h,k| h[k] = repository(k).adapter.field_naming_convention })
+      model.instance_variable_set(:@storage_names, {})
+      model.instance_variable_set(:@properties,    {})
+      model.instance_variable_set(:@field_naming_conventions, {})
       extra_extensions.each { |extension| model.extend(extension) }
     end
 
     def inherited(target)
       target.instance_variable_set(:@storage_names,       @storage_names.dup)
-      target.instance_variable_set(:@properties,          Hash.new { |h,k| h[k] = k == Repository.default_name ? PropertySet.new : h[Repository.default_name].dup })
+      target.instance_variable_set(:@properties,          {})
       target.instance_variable_set(:@base_model,          self.base_model)
       target.instance_variable_set(:@paranoid_properties, @paranoid_properties)
       target.instance_variable_set(:@field_naming_conventions,  @field_naming_conventions.dup)
@@ -58,12 +58,13 @@ module DataMapper
       end
 
       if @relationships
-        duped_relationships = Hash.new { |h,k| h[k] = {} }
+        duped_relationships = {}
         @relationships.each do |repository_name,relationships|
           relationships.each do |name, relationship|
             dup = relationship.dup
             dup.instance_variable_set(:@child_model, target) if dup.instance_variable_get(:@child_model) == self
             dup.instance_variable_set(:@parent_model, target) if dup.instance_variable_get(:@parent_model) == self
+            duped_relationships[repository_name] ||= {}
             duped_relationships[repository_name][name] = dup
           end
         end
@@ -102,13 +103,17 @@ module DataMapper
     #   if given a block, otherwise the requested repository.
     #-
     # @api public
-    def repository(name = nil, &block)
+    def repository(name = nil)
       #
       # There has been a couple of different strategies here, but me (zond) and dkubb are at least
       # united in the concept of explicitness over implicitness. That is - the explicit wish of the
       # caller (+name+) should be given more priority than the implicit wish of the caller (Repository.context.last).
       #
-      DataMapper.repository(name || repository_name, &block)
+      if block_given?
+        DataMapper.repository(name || repository_name) { |*block_args| yield(*block_args) }
+      else
+        DataMapper.repository(name || repository_name)
+      end
     end
 
     ##
@@ -116,7 +121,7 @@ module DataMapper
     #
     # @return <String> the storage name (IE table name, for database stores) associated with this resource in the given repository
     def storage_name(repository_name = default_repository_name)
-      @storage_names[repository_name]
+      @storage_names[repository_name] ||= repository(repository_name).adapter.resource_naming_convention.call(base_model.send(:default_storage_name))
     end
 
     ##
@@ -130,9 +135,9 @@ module DataMapper
     ##
     # The field naming conventions for this resource across all repositories.
     #
-    # @return <Hash(Symbol => String)> All available field naming conventions
-    def field_naming_conventions
-      @field_naming_conventions
+    # @return <String> The naming convention for the given repository
+    def field_naming_convention(repository_name = default_storage_name)
+      @field_naming_conventions[repository_name] ||= repository(repository_name).adapter.field_naming_convention
     end
 
     ##
@@ -148,14 +153,15 @@ module DataMapper
       create_property_getter(property)
       create_property_setter(property)
 
-      @properties[repository_name][property.name] = property
+      properties(repository_name)[property.name] = property
+      @_valid_relations = false
 
       # Add property to the other mappings as well if this is for the default
       # repository.
       if repository_name == default_repository_name
         @properties.each_pair do |repository_name, properties|
           next if repository_name == default_repository_name
-          properties << property
+          properties << property unless properties.has_property?(property.name)
         end
       end
 
@@ -168,7 +174,7 @@ module DataMapper
         context = :default if context == true
 
         Array(context).each do |item|
-          @properties[repository_name].lazy_context(item) << name
+          properties(repository_name).lazy_context(item) << name
         end
       end
 
@@ -190,7 +196,25 @@ module DataMapper
     end
 
     def properties(repository_name = default_repository_name)
-      @properties[repository_name]
+      # We need to check whether all relations are already set up.
+      # If this isn't the case, we try to reload them here
+      if !@_valid_relations && respond_to?(:many_to_one_relationships)
+        @_valid_relations = true
+        begin
+          many_to_one_relationships.each do |r|
+            r.child_key
+          end
+        rescue NameError
+          # Apparently not all relations are loaded,
+          # so we will try again later on
+          @_valid_relations = false
+        end
+      end
+      @properties[repository_name] ||= repository_name == Repository.default_name ? PropertySet.new : properties(Repository.default_name).dup
+    end
+
+    def eager_properties(repository_name = default_repository_name)
+      properties(repository_name).defaults
     end
 
     # @api private
@@ -207,15 +231,12 @@ module DataMapper
     end
 
     def key(repository_name = default_repository_name)
-      @properties[repository_name].key
-    end
-
-    def inheritance_property(repository_name = default_repository_name)
-      @properties[repository_name].inheritance_property
+      properties(repository_name).key
     end
 
-    def default_order
-      @default_order ||= key.map { |property| Query::Direction.new(property) }
+    def default_order(repository_name = default_repository_name)
+      @default_order ||= {}
+      @default_order[repository_name] ||= key(repository_name).map { |property| Query::Direction.new(property) }
     end
 
     def get(*key)
@@ -288,8 +309,8 @@ module DataMapper
     # TODO SPEC
     def copy(source, destination, query = {})
       repository(destination) do
-        repository(source).read_many(query).each do |resource|
-          self.create(resource)
+        repository(source).read_many(scoped_query(query)).each do |resource|
+          self.create(resource.attributes)
         end
       end
     end
@@ -300,7 +321,7 @@ module DataMapper
       repository = query.repository
       model      = self
 
-      if inheritance_property_index = query.inheritance_property_index(repository)
+      if inheritance_property_index = query.inheritance_property_index
         model = values.at(inheritance_property_index) || model
       end
 
@@ -447,8 +468,8 @@ module DataMapper
       # @api public
       #
       # TODO: move to dm-more/dm-transactions
-      def transaction(&block)
-        DataMapper::Transaction.new(self, &block)
+      def transaction
+        DataMapper::Transaction.new(self) { |block_args| yield(*block_args) }
       end
     end # module Transaction
 

data/lib/dm-core/property.rb

@@ -220,6 +220,21 @@ module DataMapper
   # dm-more bundle. For more information about validations, check the
   # documentation for dm-validations.
   #
+  # == Default Values
+  # To set a default for a property, use the <tt>:default</tt> key.  The
+  # property will be set to the value associated with that key the first time
+  # it is accessed, or when the resource is saved if it hasn't been set with
+  # another value already.  This value can be a static value, such as 'hello'
+  # but it can also be a proc that will be evaluated when the property is read
+  # before its value has been set.  The property is set to the return of the
+  # proc.  The proc is passed two values, the resource the property is being set
+  # for and the property itself.
+  #
+  #   property :display_name, String, :default => { |r, p| r.login }
+  #
+  # Word of warning.  Don't try to read the value of the property you're setting
+  # the default for in the proc.  An infinite loop will ensue.
+  #
   # == Embedded Values
   # As an alternative to extraneous has_one relationships, consider using an
   # EmbeddedValue.
@@ -287,7 +302,7 @@ module DataMapper
     # -
     # @api semi-public
     def field(repository_name = nil)
-      @field || fields[repository_name || model.repository_name]
+      @field || @fields[repository_name] ||= self.model.field_naming_convention(repository_name).call(self)
     end
 
     def unique
@@ -372,20 +387,15 @@ module DataMapper
     #-
     # @api private
     def get(resource)
-      new_record = resource.new_record?
-
-      lazy_load(resource) unless new_record || resource.attribute_loaded?(name)
+      lazy_load(resource)
 
       value = get!(resource)
 
-      case track
-        when :hash
-          resource.original_values[name] = value.dup.hash unless resource.original_values.has_key?(name) rescue value.hash
-        when :get
-          resource.original_values[name] = value.dup unless resource.original_values.has_key?(name) rescue value
-      end
+      set_original_value(resource, value)
 
-      if value.nil? && new_record && !options[:default].nil? && !resource.attribute_loaded?(name)
+      # [YK] Why did we previously care whether options[:default] is nil.
+      # The default value of nil will be applied either way
+      if value.nil? && resource.new_record? && !resource.attribute_loaded?(name)
         value = default_for(resource)
         set(resource, value)
       end
@@ -397,21 +407,32 @@ module DataMapper
       resource.instance_variable_get(instance_variable_name)
     end
 
+    def set_original_value(resource, val)
+      unless resource.original_values.key?(name)
+        val = val.try_dup
+        val = val.hash if track == :hash
+        resource.original_values[name] = val
+      end
+    end
+
     # Provides a standardized setter method for the property
     #
     # @raise <ArgumentError> "+resource+ should be a DataMapper::Resource, but was ...."
     #-
     # @api private
     def set(resource, value)
-      lazy_load(resource) unless resource.new_record? || resource.attribute_loaded?(name)
+      # [YK] We previously checked for new_record? here, but lazy loading
+      # is blocked anyway if we're in a new record by by
+      # Resource#reload_attributes. This may eventually be useful for
+      # optimizing, but let's (a) benchmark it first, and (b) do
+      # whatever refactoring is necessary, which will benefit from the
+      # centralize checking
+      lazy_load(resource)
+
       new_value = typecast(value)
       old_value = get!(resource)
 
-      # skip setting the property if the new value is equal
-      # to the old value, and the old value was defined
-      return if new_value == old_value && resource.attribute_loaded?(name)
-
-      resource.original_values[name] = old_value unless resource.original_values.has_key?(name)
+      set_original_value(resource, old_value)
 
       set!(resource, new_value)
     end
@@ -424,14 +445,13 @@ module DataMapper
     #-
     # @api private
     def lazy_load(resource)
-      # TODO: refactor this section
-      contexts = if lazy?
-        name
-      else
-        model.properties(resource.repository.name).reject do |property|
-          property.lazy? || resource.attribute_loaded?(property.name)
-        end
-      end
+      # It is faster to bail out at at a new_record? rather than to process
+      # which properties would be loaded and then not load them.
+      return if resource.new_record? || resource.attribute_loaded?(name)
+      # If we're trying to load a lazy property, load it. Otherwise, lazy-load
+      # any properties that should be eager-loaded but were not included
+      # in the original :fields list
+      contexts = lazy? ? name : model.eager_properties(resource.repository.name)
       resource.send(:lazy_load, contexts)
     end
 
@@ -457,14 +477,13 @@ module DataMapper
           # these two alternatives:
           # * Integer(value) rescue nil
           # * Integer(value_to_s =~ /(\d+)/ ? $1 : value_to_s) rescue nil
+          #
+          # [YK] The previous implementation used a rescue. Why use a rescue
+          # when the list of cases where a valid string other than "0" could
+          # produce 0 is known?
           value_to_i = value.to_i
-          if value_to_i == 0 && value != '0'
-            value_to_s = value.to_s
-            begin
-              Integer(value_to_s =~ /^(\d+)/ ? $1 : value_to_s)
-            rescue ArgumentError
-              nil
-            end
+          if value_to_i == 0
+            value.to_s =~ /^(0x|0b)?0+/ ? 0 : nil
           else
             value_to_i
           end
@@ -485,6 +504,10 @@ module DataMapper
       @default.respond_to?(:call) ? @default.call(resource, self) : @default
     end
 
+    def value(val)
+      custom? ? self.type.dump(val, self) : val
+    end
+
     def inspect
       "#<Property:#{@model}:#{@name}>"
     end
@@ -535,6 +558,7 @@ module DataMapper
       @index        = @options.fetch(:index,        false)
       @unique_index = @options.fetch(:unique_index, false)
       @lazy         = @options.fetch(:lazy,         @type.respond_to?(:lazy) ? @type.lazy : false) && !@key
+      @fields       = {}
 
       @track = @options.fetch(:track) do
         if @custom && @type.respond_to?(:track) && @type.track
@@ -575,10 +599,6 @@ module DataMapper
       @model.property_serialization_setup(self) if @model.respond_to?(:property_serialization_setup)
     end
 
-    def fields
-      @fields ||= Hash.new { |h,k| h[k] = self.model.field_naming_conventions[k].call(self) }
-    end
-
     def determine_visibility # :nodoc:
       @reader_visibility = @options[:reader] || @options[:accessor] || :public
       @writer_visibility = @options[:writer] || @options[:accessor] || :public
@@ -615,7 +635,7 @@ module DataMapper
     def typecast_hash_to_datetime(hash)
       args = extract_time_args_from_hash(hash, :year, :month, :day, :hour, :min, :sec)
       DateTime.new(*args)
-    rescue ArgumentError
+    rescue ArgumentError => e
       t = typecast_hash_to_time(hash)
       DateTime.new(t.year, t.month, t.day, t.hour, t.min, t.sec)
     end