dm-core 0.9.2 → 0.9.3

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

@@ -10,6 +10,7 @@ module DataMapper
       undef_method :get_parent
       undef_method :attach_parent
 
+      # @api private
       def child_model
         near_relationship.child_model
       end
@@ -18,38 +19,19 @@ module DataMapper
       def get_children(parent, options = {}, finder = :all, *args)
         query = @query.merge(options).merge(child_key.to_query(parent_key.get(parent)))
 
-        query[:links] = links
+        query[:links]  = links
+        query[:unique] = true
 
-        DataMapper.repository(parent.repository.name) do
+        with_repository(parent) do
           results = grandchild_model.send(finder, *(args << query))
           # FIXME: remove the need for the uniq.freeze
-          finder == :all ? (@mutable ? results.uniq : results.uniq.freeze) : results
+          finder == :all ? (@mutable ? results : results.freeze) : results
         end
       end
 
       private
 
-      def near_relationship
-        parent_model.relationships[@near_relationship_name]
-      end
-
-      def links
-        if remote_relationship.kind_of?(RelationshipChain)
-          remote_relationship.instance_eval { links } + [remote_relationship.instance_eval { near_relationship } ]
-        else
-          [ remote_relationship ]
-        end
-      end
-
-      def remote_relationship
-        near_relationship.child_model.relationships[@remote_relationship_name] ||
-          near_relationship.child_model.relationships[@remote_relationship_name.to_s.singularize.to_sym]
-      end
-
-      def grandchild_model
-        Class === @child_model ? @child_model : self.class.find_const(@child_model)
-      end
-
+      # @api private
       def initialize(options)
         if (missing_options = OPTIONS - [ :min, :max ] - options.keys ).any?
           raise ArgumentError, "The options #{missing_options * ', '} are required", caller
@@ -69,6 +51,31 @@ module DataMapper
         @extra_links = []
         @options     = options
       end
+
+      # @api private
+      def near_relationship
+        parent_model.relationships[@near_relationship_name]
+      end
+
+      # @api private
+      def links
+        if remote_relationship.kind_of?(RelationshipChain)
+          remote_relationship.instance_eval { links } + [remote_relationship.instance_eval { near_relationship } ]
+        else
+          [ remote_relationship ]
+        end
+      end
+
+      # @api private
+      def remote_relationship
+        near_relationship.child_model.relationships[@remote_relationship_name] ||
+          near_relationship.child_model.relationships[@remote_relationship_name.to_s.singularize.to_sym]
+      end
+
+      # @api private
+      def grandchild_model
+        Class === @child_model ? @child_model : (Class === @parent_model ? @parent_model.find_const(@child_model) : Object.find_const(@child_model))
+      end
     end # class Relationship
   end # module Associations
 end # module DataMapper

data/lib/dm-core/auto_migrations.rb

@@ -37,9 +37,7 @@ module DataMapper
       if self.superclass != Object
         self.superclass.auto_migrate!(repository_name)
       else
-        repository_name ||= default_repository_name
         repository(repository_name) do |r|
-          (relationships(r.name)||{}).each_value { |relationship| relationship.child_key }
           r.adapter.destroy_model_storage(r, self)
           r.adapter.create_model_storage(r, self)
         end
@@ -52,9 +50,7 @@ module DataMapper
     #
     # @param Symbol repository_name the repository to be migrated
     def auto_upgrade!(repository_name = nil)
-      repository_name ||= default_repository_name
       repository(repository_name) do |r|
-        (relationships(r.name)||{}).each_value { |relationship| relationship.child_key }
         r.adapter.upgrade_model_storage(r, self)
       end
     end

data/lib/dm-core/collection.rb

@@ -50,6 +50,7 @@ module DataMapper
     #
     # @api public
     def get(*key)
+      key = model.typecast_key(key)
       if loaded?
         # loop over the collection to find the matching resource
         detect { |resource| resource.key == key }
@@ -318,8 +319,22 @@ module DataMapper
       self
     end
 
+    # builds a new resource and appends it to the collection
+    #
+    # @param Hash[Symbol => Object] attributes attributes which
+    #   the new resource should have.
+    #
+    # @api public
+    def build(attributes = {})
+      repository.scope do
+        resource = model.new(default_attributes.merge(attributes))
+        self << resource
+        resource
+      end
+    end
+
     ##
-    # creates a new array, saves it, and << it onto the collection
+    # creates a new resource, saves it, and appends it to the collection
     #
     # @param Hash[Symbol => Object] attributes attributes which
     #   the new resource should have.
@@ -462,12 +477,26 @@ module DataMapper
       default_attributes
     end
 
+    ##
+    # check to see if collection can respond to the method
+    #
+    # @param method [Symbol] method to check in the object
+    # @param include_private [FalseClass, TrueClass] if set to true,
+    #   collection will check private methods
+    #
+    # @return [TrueClass, FalseClass]
+    #   TrueClass indicates the method can be responded to by the collection
+    #   FalseClass indicates the method can not be responded to by the collection
+    #
+    # @api public
+    def respond_to?(method, include_private = false)
+      super || model.public_methods(false).include?(method.to_s) || relationships.has_key?(method)
+    end
+
     protected
 
     ##
     # @api private
-    #
-    # @api public
     def model
       query.model
     end
@@ -579,7 +608,11 @@ module DataMapper
     ##
     # @api private
     def method_missing(method, *args, &block)
-      if relationship = relationships[method]
+      if model.public_methods(false).include?(method.to_s)
+        model.send(:with_scope, query) do
+          model.send(method, *args, &block)
+        end
+      elsif relationship = relationships[method]
         klass = model == relationship.child_model ? relationship.parent_model : relationship.child_model
 
         # TODO: when self.query includes an offset/limit use it as a
@@ -595,10 +628,10 @@ module DataMapper
           :links  => self.query.links + [ relationship ]
         )
 
-        return klass.all(query, &block)
+        klass.all(query, &block)
+      else
+        super
       end
-
-      super
     end
   end # class Collection
 end # module DataMapper

data/lib/dm-core/dependency_queue.rb

@@ -0,0 +1,31 @@
+module DataMapper
+  ##
+  #
+  # DataMapper's DependencyQueue is used to store callbacks for classes which
+  # may or may not be loaded already.
+  #
+  class DependencyQueue
+    def initialize
+      @dependencies = Hash.new { |h,k| h[k] = [] }
+    end
+
+    def add(class_name, &callback)
+      @dependencies[class_name] << callback
+      resolve!
+    end
+
+    def resolve!
+      @dependencies.each do |class_name, callbacks|
+        begin
+          klass = Object.find_const(class_name)
+          callbacks.each do |callback|
+            callback.call(klass)
+          end
+          callbacks.clear
+        rescue NameError
+        end
+      end
+    end
+
+  end # class DependencyQueue
+end # module DataMapper

data/lib/dm-core/hook.rb

@@ -1,10 +1,10 @@
 module DataMapper
   module Hook
     def self.included(model)
-      model.class_eval %{
+      model.class_eval <<-EOS, __FILE__, __LINE__
         include Extlib::Hook
         register_instance_hooks :save, :create, :update, :destroy
-      }
+      EOS
     end
   end
   DataMapper::Resource.append_inclusions Hook

data/lib/dm-core/is.rb

@@ -1,11 +1,11 @@
 module DataMapper
   module Is
 
-    def is(plugin,*pars)
+    def is(plugin, *pars, &block)
       generator_method = "is_#{plugin}".to_sym
 
       if self.respond_to?(generator_method)
-        self.send(generator_method,*pars)
+        self.send(generator_method, *pars, &block)
       else
         raise PluginNotFoundError, "could not find plugin named #{plugin}"
       end

data/lib/dm-core/logger.rb

@@ -213,19 +213,19 @@ module DataMapper
     #  :off only gets a off? method
     LEVELS.each_pair do |name, number|
       unless name.to_s == 'off'
-        class_eval <<-EOS
-        # DOC
-        def #{name}(message)
-          self.<<( prep_msg(message, "#{name}") ) if #{name}?
-        end
+        class_eval <<-EOS, __FILE__, __LINE__
+          # DOC
+          def #{name}(message)
+            self.<<( prep_msg(message, "#{name}") ) if #{name}?
+          end
         EOS
       end
 
-      class_eval <<-EOS
-      # DOC
-      def #{name}?
-        #{number} >= level
-      end
+      class_eval <<-EOS, __FILE__, __LINE__
+        # DOC
+        def #{name}?
+          #{number} >= level
+        end
       EOS
     end
 

data/lib/dm-core/model.rb

@@ -1,3 +1,5 @@
+require 'set'
+
 module DataMapper
   module Model
     ##
@@ -21,23 +23,43 @@ module DataMapper
       extra_extensions.concat extensions
       true
     end
-    
+
     def self.extra_extensions
       @extra_extensions ||= []
     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.instance_eval { default_storage_name }) })
+      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 })
       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 ? self.properties(Repository.default_name).dup(target) : h[Repository.default_name].dup })
+      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(:@base_model,          self.base_model)
+      target.instance_variable_set(:@paranoid_properties, @paranoid_properties)
+      target.instance_variable_set(:@validations,         @validations.dup) if self.respond_to?(:validators)
+
+      @properties.each do |repository_name,properties|
+        repository(repository_name) do
+          properties.each do |property|
+            next if target.properties(repository_name).has_property?(property.name)
+            target.property(property.name, property.type, property.options.dup)
+          end
+        end
+      end
 
       if @relationships
-        duped_relationships = {}; @relationships.each_pair{ |repos, rels| duped_relationships[repos] = rels.dup}
+        duped_relationships = Hash.new { |h,k| h[k] = {} }
+        @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][name] = dup
+          end
+        end
         target.instance_variable_set(:@relationships, duped_relationships)
       end
     end
@@ -54,6 +76,14 @@ module DataMapper
       model
     end
 
+    def base_model
+      @base_model ||= self
+    end
+
+    def repository_name
+      Repository.context.any? ? Repository.context.last.name : default_repository_name
+    end
+
     ##
     # Get the repository with a given name, or the default one for the current
     # context, or the default one for this class.
@@ -71,7 +101,7 @@ module DataMapper
       # 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(*Array(name || (Repository.context.last ? nil : default_repository_name)), &block)
+      DataMapper.repository(name || repository_name, &block)
     end
 
     ##
@@ -103,11 +133,11 @@ module DataMapper
       create_property_getter(property)
       create_property_setter(property)
 
-      @properties[repository.name] << property
+      @properties[repository_name] << property
 
       # Add property to the other mappings as well if this is for the default
       # repository.
-      if repository.name == default_repository_name
+      if repository_name == default_repository_name
         @properties.each_pair do |repository_name, properties|
           next if repository_name == default_repository_name
           properties << property
@@ -123,35 +153,42 @@ 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
+
+      # add the property to the child classes only if the property was
+      # added after the child classes' properties have been copied from
+      # the parent
+      if respond_to?(:descendants)
+        descendants.each do |model|
+          next if model.properties(repository_name).has_property?(name)
+          model.property(name, type, options)
         end
       end
 
       property
     end
 
-    # TODO: make this a Set?
     def repositories
-      [ repository ] + @properties.keys.collect { |repository_name| DataMapper.repository(repository_name) }
+      [ repository ].to_set + @properties.keys.collect { |repository_name| DataMapper.repository(repository_name) }
     end
 
     def properties(repository_name = default_repository_name)
       @properties[repository_name]
     end
 
+    # @api private
     def properties_with_subclasses(repository_name = default_repository_name)
-      #return properties if we're not interested in sti
-     if @properties[repository_name].inheritance_property.nil?
-       @properties[repository_name]
-     else
-        props = @properties[repository_name].dup
-        self.child_classes.each do |subclass|
-          subclass.properties(repository_name).each do |subprop|
-            props << subprop if not props.any? { |prop| prop.name == subprop.name }
-          end
+      properties = PropertySet.new
+      ([ self ].to_set + (respond_to?(:descendants) ? descendants : [])).each do |model|
+        model.relationships(repository_name).each_value { |relationship| relationship.child_key }
+        model.many_to_one_relationships.each do |relationship| relationship.child_key end
+        model.properties(repository_name).each do |property|
+          properties << property unless properties.has_property?(property.name)
         end
-        props
       end
+      properties
     end
 
     def key(repository_name = default_repository_name)
@@ -167,6 +204,7 @@ module DataMapper
     end
 
     def get(*key)
+      key = typecast_key(key)
       repository.identity_map(self).get(key) || first(to_query(repository, key))
     end
 
@@ -200,7 +238,7 @@ module DataMapper
         resource = allocate
         query = query.dup
 
-        properties(repository.name).key.each do |property|
+        properties(repository_name).key.each do |property|
           if value = query.delete(property.name)
             resource.send("#{property.name}=", value)
           end
@@ -223,12 +261,10 @@ module DataMapper
     end
 
     ##
-    # Dangerous version of #create.  Raises if there is a failure
-    #
-    # @see DataMapper::Resource#create
-    # @param <Hash(Symbol => Object)> attributes hash of attributes to set
-    # @raise <PersistenceError> The resource could not be saved
+    # This method is deprecated, and will be removed from dm-core.
+    # 
     def create!(attributes = {})
+      warn("Model#create! is deprecated. It is moving to dm-validations, and will be used to create a record without validations")
       resource = create(attributes)
       raise PersistenceError, "Resource not saved: :new_record => #{resource.new_record?}, :dirty_attributes => #{resource.dirty_attributes.inspect}" if resource.new_record?
       resource
@@ -280,7 +316,7 @@ module DataMapper
             when :hash
               resource.original_values[property.name] = value.dup.hash unless resource.original_values.has_key?(property.name) rescue value.hash
             when :load
-               resource.original_values[property.name] = value unless resource.original_values.has_key?(property.name)
+              resource.original_values[property.name] = value unless resource.original_values.has_key?(property.name)
           end
         end
       end
@@ -290,20 +326,29 @@ 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
 
-    private
-
-    def default_storage_name
-      self.name
+    def typecast_key(key)
+      self.key(repository_name).zip(key).map { |k, v| k.typecast(v) }
     end
 
     def default_repository_name
       Repository.default_name
     end
 
+    def paranoid_properties
+      @paranoid_properties ||= {}
+      @paranoid_properties
+    end
+
+    private
+
+    def default_storage_name
+      self.name
+    end
+
     def scoped_query(query = self.query)
       assert_kind_of 'query', query, Query, Hash
 
@@ -315,7 +360,15 @@ module DataMapper
         query
       end
 
-      self.query ? self.query.merge(query) : query
+      if self.query
+        self.query.merge(query)
+      else
+        merge_with_default_scope(query)
+      end
+    end
+
+    def set_paranoid_property(name, &block)
+      self.paranoid_properties[name] = block
     end
 
     # defines the getter for the property
@@ -327,7 +380,7 @@ module DataMapper
         end
       EOS
 
-      if property.primitive == TrueClass && !property.model.instance_methods.include?(property.name.to_s)
+      if property.primitive == TrueClass && !instance_methods.include?(property.name.to_s)
         class_eval <<-EOS, __FILE__, __LINE__
           #{property.reader_visibility}
           alias #{property.name} #{property.getter}
@@ -337,7 +390,7 @@ module DataMapper
 
     # defines the setter for the property
     def create_property_setter(property)
-      unless instance_methods.include?(property.name.to_s + '=')
+      unless instance_methods.include?("#{property.name}=")
         class_eval <<-EOS, __FILE__, __LINE__
           #{property.writer_visibility}
           def #{property.name}=(value)
@@ -353,14 +406,14 @@ module DataMapper
       # a missing module can cause misleading recursive errors.
       raise NotImplementedError.new
     end
-    
-    def method_missing(method, *args, &block)      
-      if relationship = self.relationships(repository.name)[method]
+
+    def method_missing(method, *args, &block)
+      if relationship = self.relationships(repository_name)[method]
         klass = self == relationship.child_model ? relationship.parent_model : relationship.child_model
         return DataMapper::Query::Path.new(repository, [ relationship ], klass)
       end
 
-      if property = properties(repository.name)[method]
+      if property = properties(repository_name)[method]
         return property
       end