sam-dm-core 0.9.6 → 0.9.7

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] }
@@ -157,14 +162,14 @@ module DataMapper
       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

@@ -73,12 +73,8 @@ module DataMapper
     # @api private
     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
-        repository(repository_name) do |r|
-          r.adapter.destroy_model_storage(r, self)
-        end
+      repository(repository_name) do |r|
+        r.adapter.destroy_model_storage(r, self.base_model)
       end
     end
 
@@ -88,12 +84,8 @@ module DataMapper
     # @param Symbol repository_name the repository to be migrated
     # @api private
     def auto_migrate_up!(repository_name = self.repository_name)
-      if self.superclass != Object
-        self.superclass.auto_migrate!(repository_name)
-      else
-        repository(repository_name) do |r|
-          r.adapter.create_model_storage(r, self)
-        end
+      repository(repository_name) do |r|
+        r.adapter.create_model_storage(r, self.base_model)
       end
     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
 

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,7 +153,8 @@ 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.
@@ -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,11 +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
+      properties(repository_name).defaults
     end
 
     # @api private
@@ -211,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(repository_name = default_repository_name)
-      key(repository_name).map { |property| Query::Direction.new(property) }
+      @default_order ||= {}
+      @default_order[repository_name] ||= key(repository_name).map { |property| Query::Direction.new(property) }
     end
 
     def get(*key)
@@ -292,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
@@ -304,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
 
@@ -345,7 +362,7 @@ module DataMapper
 
     # TODO: spec this
     def to_query(repository, key, query = {})
-      conditions = Hash[ *self.key(repository_name).zip(key).flatten ]
+      conditions = Hash[ *self.key(repository.name).zip(key).flatten ]
       Query.new(repository, self, query.merge(conditions))
     end
 
@@ -451,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

@@ -302,7 +302,7 @@ module DataMapper
     # -
     # @api semi-public
     def field(repository_name = nil)
-      @field  || fields[repository_name]
+      @field || @fields[repository_name] ||= self.model.field_naming_convention(repository_name).call(self)
     end
 
     def unique
@@ -432,13 +432,6 @@ module DataMapper
       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
-      # ---
-      # [YK] Why bother? Does this change the result at all?
-      # ---
-      # return if new_value == old_value && resource.attribute_loaded?(name)
-
       set_original_value(resource, old_value)
 
       set!(resource, new_value)
@@ -458,7 +451,7 @@ module DataMapper
       # 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).map {|property| property.name}
+      contexts = lazy? ? name : model.eager_properties(resource.repository.name)
       resource.send(:lazy_load, contexts)
     end
 
@@ -565,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
@@ -605,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

data/lib/dm-core/property_set.rb

@@ -4,10 +4,11 @@ module DataMapper
     include Enumerable
 
     def [](name)
-      @property_for[name] || raise(ArgumentError, "Unknown property '#{name}'", caller)
+      property_for(name) || raise(ArgumentError, "Unknown property '#{name}'", caller)
     end
 
     def []=(name, property)
+      @key, @defaults = nil
       if existing_property = detect { |p| p.name == name }
         property.hash
         @entries[@entries.index(existing_property)] = property
@@ -18,14 +19,23 @@ module DataMapper
     end
 
     def has_property?(name)
-      !!@property_for[name]
+      !!property_for(name)
     end
 
     def slice(*names)
-      @property_for.values_at(*names)
+      @key, @defaults = nil
+      names.map do |name|
+        property_for(name)
+      end
+    end
+
+    def clear
+      @key, @defaults = nil
+      @entries.clear
     end
 
     def add(*properties)
+      @key, @defaults = nil
       @entries.push(*properties)
       properties.each { |property| property.hash }
       self
@@ -47,11 +57,11 @@ module DataMapper
     end
 
     def defaults
-      reject { |property| property.lazy? }
+      @defaults ||= reject { |property| property.lazy? }
     end
 
     def key
-      select { |property| property.key? }
+      @key ||= select { |property| property.key? }
     end
 
     def indexes
@@ -68,10 +78,6 @@ module DataMapper
       index_hash
     end
 
-    def inheritance_property
-      detect { |property| property.type == DataMapper::Types::Discriminator }
-    end
-
     def get(resource)
       map { |property| property.get(resource) }
     end
@@ -93,7 +99,7 @@ module DataMapper
     end
 
     def lazy_context(name)
-      lazy_contexts[name]
+      lazy_contexts[name] ||= []
     end
 
     def lazy_load_context(names)
@@ -128,25 +134,17 @@ module DataMapper
       assert_kind_of 'properties', properties, Enumerable
 
       @entries = properties
-      @property_for = hash_for_property_for
+      @property_for = {}
     end
 
     def initialize_copy(orig)
+      @key, @defaults = nil
       @entries = orig.entries.dup
-      @property_for = hash_for_property_for
-    end
-
-    def hash_for_property_for
-      Hash.new do |h,k|
-        ksym = k.to_sym
-        if property = detect { |property| property.name == ksym }
-          h[ksym] = h[k.to_s] = property
-        end
-      end
+      @property_for = {}
     end
 
     def lazy_contexts
-      @lazy_contexts ||= Hash.new { |h,context| h[context] = [] }
+      @lazy_contexts ||= {}
     end
 
     def parse_index(index, property, index_hash)
@@ -158,5 +156,14 @@ module DataMapper
       when Enumerable then index.each { |idx| parse_index(idx, property, index_hash) }
       end
     end
+
+    def property_for(name)
+      unless @property_for[name]
+        property = detect { |property| property.name == name.to_sym }
+        @property_for[name.to_s] = @property_for[name.to_sym] = property if property
+      end
+      @property_for[name]
+    end
+
   end # class PropertySet
 end # module DataMapper