dm-core 0.9.5 → 0.9.6

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

data/lib/dm-core/query.rb

@@ -99,9 +99,12 @@ module DataMapper
       bind_values
     end
 
-    # TODO: spec this
-    def inheritance_property_index(repository)
-      fields.index(model.inheritance_property(repository.name))
+    def inheritance_property
+      fields.detect { |property| property.type == DataMapper::Types::Discriminator }
+    end
+
+    def inheritance_property_index
+      fields.index(inheritance_property)
     end
 
     # TODO: spec this
@@ -167,7 +170,7 @@ module DataMapper
       @unique       = options.fetch :unique,       false  # must be true or false
       @offset       = options.fetch :offset,       0      # must be an Integer greater than or equal to 0
       @limit        = options.fetch :limit,        nil    # must be an Integer greater than or equal to 1
-      @order        = options.fetch :order,        model.default_order   # must be an Array of Symbol, DM::Query::Direction or DM::Property
+      @order        = options.fetch :order,        model.default_order(@repository.name)   # must be an Array of Symbol, DM::Query::Direction or DM::Property
       @add_reversed = options.fetch :add_reversed, false  # must be true or false
       @fields       = options.fetch :fields,       @properties.defaults  # must be an Array of Symbol, String or DM::Property
       @links        = options.fetch :links,        []     # must be an Array of Tuples - Tuple [DM::Query,DM::Assoc::Relationship]
@@ -190,7 +193,7 @@ module DataMapper
       @includes = normalize_includes(@includes)
 
       # treat all non-options as conditions
-      (options.keys - OPTIONS - OPTIONS.map { |option| option.to_s }).each do |k|
+      (options.keys - OPTIONS).each do |k|
         append_condition(k, options[k])
       end
 
@@ -218,53 +221,50 @@ module DataMapper
 
     # validate the options
     def assert_valid_options(options)
-      # validate the reload option and unique option
-      ([ :reload, :unique ] & options.keys).each do |attribute|
-        if options[attribute] != true && options[attribute] != false
-          raise ArgumentError, "+options[:#{attribute}]+ must be true or false, but was #{options[attribute].inspect}", caller(2)
-        end
-      end
-
-      # validate the offset and limit options
-      ([ :offset, :limit ] & options.keys).each do |attribute|
-        value = options[attribute]
-        assert_kind_of "options[:#{attribute}]", value, Integer
-      end
-
-      if options.has_key?(:offset) && options[:offset] < 0
-        raise ArgumentError, "+options[:offset]+ must be greater than or equal to 0, but was #{options[:offset].inspect}", caller(2)
-      end
-
-      if options.has_key?(:limit)  && options[:limit] < 1
-        raise ArgumentError, "+options[:limit]+ must be greater than or equal to 1, but was #{options[:limit].inspect}", caller(2)
-      end
+      # [DB] This might look more ugly now, but it's 2x as fast as the old code
+      # [DB] This is one of the heavy spots for Query.new I found during profiling.
+      options.each_pair do |attribute, value|
+
+        # validate the reload option and unique option
+        if [:reload, :unique].include? attribute
+          if value != true && value != false
+            raise ArgumentError, "+options[:#{attribute}]+ must be true or false, but was #{value.inspect}", caller(2)
+          end
 
-      # validate the order, fields, links, includes and conditions options
-      ([ :order, :fields, :links, :includes ] & options.keys).each do |attribute|
-        value = options[attribute]
-        assert_kind_of "options[:#{attribute}]", value, Array
+        # validate the offset and limit options
+        elsif [:offset, :limit].include? attribute
+          assert_kind_of "options[:#{attribute}]", value, Integer
+          if attribute == :offset && value < 0
+            raise ArgumentError, "+options[:offset]+ must be greater than or equal to 0, but was #{value.inspect}", caller(2)
+          elsif attribute == :limit && value < 1
+            raise ArgumentError, "+options[:limit]+ must be greater than or equal to 1, but was #{options[:limit].inspect}", caller(2)
+          end
 
-        if value.empty?
-          if attribute == :fields
-            if options[:unique] == false
-              raise ArgumentError, '+options[:fields]+ cannot be empty if +options[:unique] is false', caller(2)
-            end
-          elsif attribute == :order
-            if options[:fields] && options[:fields].any? { |p| !p.kind_of?(Operator) }
-              raise ArgumentError, '+options[:order]+ cannot be empty if +options[:fields] contains a non-operator', caller(2)
+        # validate the :order, :fields, :links and :includes options
+        elsif [ :order, :fields, :links, :includes ].include? attribute
+          assert_kind_of "options[:#{attribute}]", value, Array
+
+          if value.empty?
+            if attribute == :fields
+              if options[:unique] == false
+                raise ArgumentError, '+options[:fields]+ cannot be empty if +options[:unique] is false', caller(2)
+              end
+            elsif attribute == :order
+              if options[:fields] && options[:fields].any? { |p| !p.kind_of?(Operator) }
+                raise ArgumentError, '+options[:order]+ cannot be empty if +options[:fields] contains a non-operator', caller(2)
+              end
+            else
+              raise ArgumentError, "+options[:#{attribute}]+ cannot be empty", caller(2)
             end
-          else
-            raise ArgumentError, "+options[:#{attribute}]+ cannot be empty", caller(2)
           end
-        end
-      end
 
-      if options.has_key?(:conditions)
-        value = options[:conditions]
-        assert_kind_of 'options[:conditions]', value, Hash, Array
+        # validates the :conditions option
+        elsif :conditions == attribute
+          assert_kind_of 'options[:conditions]', value, Hash, Array
 
-        if value.empty?
-          raise ArgumentError, '+options[:conditions]+ cannot be empty', caller(2)
+          if value.empty?
+            raise ArgumentError, '+options[:conditions]+ cannot be empty', caller(2)
+          end
         end
       end
     end
@@ -402,6 +402,7 @@ module DataMapper
           clause
         when Operator
           operator = clause.operator
+          return if operator == :not && bind_value == []
           if clause.target.is_a?(Symbol)
             @properties[clause.target]
           elsif clause.target.is_a?(Query::Path)
@@ -438,7 +439,7 @@ module DataMapper
         dump_custom_value(property_or_path.property, bind_value)
       when Property
         if property_or_path.custom?
-          property_or_path.type.dump(bind_value, property_or_path) 
+          property_or_path.type.dump(bind_value, property_or_path)
         else
           bind_value
         end
@@ -463,10 +464,11 @@ module DataMapper
 
       # build an index of conditions by the property and operator to
       # avoid nested looping
-      conditions_index = Hash.new { |h,k| h[k] = {} }
+      conditions_index = {}
       @conditions.each do |condition|
         operator, property = *condition
         next if :raw == operator
+        conditions_index[property] ||= {}
         conditions_index[property][operator] = condition
       end
 
@@ -476,6 +478,7 @@ module DataMapper
         other_operator, other_property, other_bind_value = *other_condition
 
         unless :raw == other_operator
+          conditions_index[other_property] ||= {}
           if condition = conditions_index[other_property][other_operator]
             operator, property, bind_value = *condition
 
@@ -587,6 +590,11 @@ module DataMapper
         @property ? @property.field(*args) : nil
       end
 
+      # more duck typing
+      def to_sym
+        @property ? @property.name.to_sym : @model.storage_name(@repository).to_sym
+      end
+
       private
 
       def initialize(repository, relationships, model, property_name = nil)
@@ -608,7 +616,7 @@ module DataMapper
         end
 
         if @model.properties(@repository.name)[method]
-          @property = @model.properties(@repository.name)[method]
+          @property = @model.properties(@repository.name)[method] unless @property
           return self
         end
 

data/lib/dm-core/repository.rb

@@ -33,11 +33,11 @@ module DataMapper
     end
 
     def identity_map(model)
-      @identity_maps[model]
+      @identity_maps[model] ||= IdentityMap.new
     end
 
     # TODO: spec this
-    def scope(&block)
+    def scope
       Repository.context << self
 
       begin
@@ -97,7 +97,7 @@ module DataMapper
       assert_kind_of 'name', name, Symbol
 
       @name          = name
-      @identity_maps = Hash.new { |h,model| h[model] = IdentityMap.new }
+      @identity_maps = {}
     end
 
     # TODO: move to dm-more/dm-migrations

data/lib/dm-core/resource.rb

@@ -40,6 +40,10 @@ module DataMapper
       model.const_set('Resource', self) unless model.const_defined?('Resource')
       extra_inclusions.each { |inclusion| model.send(:include, inclusion) }
       descendants << model
+      class << model
+        @_valid_model = false
+        attr_reader :_valid_model
+      end
     end
 
     # Return all classes that include the DataMapper::Resource module
@@ -53,7 +57,7 @@ module DataMapper
     #     include DataMapper::Resource
     #   end
     #
-    #   DataMapper.Resource.decendents[1].type == Foo
+    #   DataMapper::Resource.descendants.to_a.first == Foo
     #
     # -
     # @api semipublic
@@ -273,9 +277,7 @@ module DataMapper
       associations_saved = false
       child_associations.each { |a| associations_saved |= a.save }
 
-      saved = if dirty? || (new_record? && key_properties.any? { |p| p.serial? })
-        new_record? ? create : update
-      end
+      saved = new_record? ? create : update
 
       if saved
         original_values.clear
@@ -377,20 +379,15 @@ module DataMapper
         property  = properties[name]
         new_value = property.get!(self)
 
-        if property.custom?
-          new_value = property.type.dump(new_value, property)
-          old_value = property.type.dump(old_value, property)
-        end
-
         dirty = case property.track
-          when :hash then old_value != new_value.hash
-          else
-            old_value != new_value
+        when :hash then old_value != new_value.hash
+        else
+          property.value(old_value) != property.value(new_value)
         end
 
         if dirty
           property.hash
-          dirty_attributes[property] = new_value
+          dirty_attributes[property] = property.value(new_value)
         end
       end
 
@@ -547,6 +544,8 @@ module DataMapper
 
     # Needs to be a protected method so that it is hookable
     def create
+      # Can't create a resource that is not dirty and doesn't have serial keys
+      return false if new_record? && !dirty? && !model.key.any? { |p| p.serial? }
       # set defaults for new resource
       properties.each do |property|
         next if attribute_loaded?(property.name)
@@ -578,6 +577,7 @@ module DataMapper
     end
 
     def assert_valid_model # :nodoc:
+      return if self.class._valid_model
       properties = self.properties
 
       if properties.empty? && relationships.empty?
@@ -587,6 +587,8 @@ module DataMapper
       if properties.key.empty?
         raise IncompleteResourceError, "#{model.name} must have a key."
       end
+
+      self.class.instance_variable_set("@_valid_model", true)
     end
 
     # TODO document
@@ -625,8 +627,8 @@ module DataMapper
       # @api public
       #
       # TODO: move to dm-more/dm-transactions
-      def transaction(&block)
-        model.transaction(&block)
+      def transaction
+        model.transaction { |*block_args| yield(*block_args) }
       end
     end # module Transaction
 

data/lib/dm-core/scope.rb

@@ -5,8 +5,8 @@ module DataMapper
     # @api private
     def default_scope(repository_name = nil)
       repository_name = self.default_repository_name if repository_name == :default || repository_name.nil?
-      @default_scope ||= Hash.new{|h,k| h[k] = {}}
-      @default_scope[repository_name]
+      @default_scope ||= {}
+      @default_scope[repository_name] ||= {}
     end
 
     # @api private
@@ -17,13 +17,13 @@ module DataMapper
     protected
 
     # @api semipublic
-    def with_scope(query, &block)
+    def with_scope(query)
       # merge the current scope with the passed in query
-      with_exclusive_scope(self.query ? self.query.merge(query) : query, &block)
+      with_exclusive_scope(self.query ? self.query.merge(query) : query) {|*block_args| yield(*block_args) }
     end
 
     # @api semipublic
-    def with_exclusive_scope(query, &block)
+    def with_exclusive_scope(query)
       query = DataMapper::Query.new(repository, self, query) if query.kind_of?(Hash)
 
       scope_stack << query
@@ -44,8 +44,8 @@ module DataMapper
 
     # @api private
     def scope_stack
-      scope_stack_for = Thread.current[:dm_scope_stack] ||= Hash.new { |h,model| h[model] = [] }
-      scope_stack_for[self]
+      scope_stack_for = Thread.current[:dm_scope_stack] ||= {}
+      scope_stack_for[self] ||= []
     end
 
     # @api private

data/lib/dm-core/support/kernel.rb

@@ -1,7 +1,11 @@
 module Kernel
   # Delegates to DataMapper::repository.
   # Will not overwrite if a method of the same name is pre-defined.
-  def repository(*args, &block)
-    DataMapper.repository(*args, &block)
+  def repository(*args)
+    if block_given?
+      DataMapper.repository(*args) { |*block_args| yield(*block_args) }
+    else
+      DataMapper.repository(*args)
+    end
   end
 end # module Kernel