dm-core 0.9.3 → 0.9.4

data/lib/dm-core/collection.rb

@@ -509,7 +509,8 @@ module DataMapper
       assert_kind_of 'query', query, Query
 
       unless block_given?
-        raise ArgumentError, 'a block must be supplied for lazy loading results', caller
+        # It can be helpful (relationship.rb: 112-13, used for SEL) to have a non-lazy Collection.
+        block = lambda {}
       end
 
       @query          = query

data/lib/dm-core/logger.rb

@@ -4,10 +4,10 @@ require "time" # httpdate
 # Logger taken from Merb :)
 #
 # To replace an existing logger with a new one:
-#  DataMapper::Logger.set_log(log{String, IO},level{Symbol, String})
+#   DataMapper.logger.set_log(log{String, IO},level{Symbol, String})
 #
-# Available logging levels are
-#   DataMapper::Logger::{ Fatal, Error, Warn, Info, Debug }
+# Available logging levels are:
+#   :off, :fatal, :error, :warn, :info, :debug
 #
 # Logging via:
 #   DataMapper.logger.fatal(message<String>)
@@ -25,7 +25,7 @@ require "time" # httpdate
 # ==== Private DataMapper Logger API
 #
 # To initialize the logger you create a new object, proxies to set_log.
-#   DataMapper::Logger.new(log{String, IO},level{Symbol, String})
+#   DataMapper::Logger.new(log{String, IO}, level{Symbol, String})
 #
 # Logger will not create the file until something is actually logged
 # This avoids file creation on DataMapper init when it creates the
@@ -147,8 +147,7 @@ module DataMapper
     end
 
     # To replace an existing logger with a new one:
-    #  DataMapper::Logger.set_log(log{String, IO},level{Symbol, String})
-    #
+    #   DataMapper.logger.set_log(log{String, IO},level{Symbol, String})
     #
     # @param log<IO,String>        either an IO object or a name of a logfile.
     # @param log_level<Symbol>     a symbol representing the log level from

data/lib/dm-core/model.rb

@@ -31,6 +31,7 @@ module DataMapper
     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 })
       extra_extensions.each { |extension| model.extend(extension) }
     end
 
@@ -39,7 +40,13 @@ module DataMapper
       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)
+      target.instance_variable_set(:@field_naming_conventions,  @field_naming_conventions.dup)
+
+      if self.respond_to?(:validators)
+        @validations.contexts.each do |context, validators|
+          validators.each { |validator| target.validators.context(context) << validator }
+        end
+      end
 
       @properties.each do |repository_name,properties|
         repository(repository_name) do
@@ -120,6 +127,14 @@ module DataMapper
       @storage_names
     end
 
+    ##
+    # 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
+    end
+
     ##
     # defines a property on the resource
     #
@@ -262,7 +277,7 @@ module DataMapper
 
     ##
     # 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)

data/lib/dm-core/naming_conventions.rb

@@ -4,7 +4,7 @@ module DataMapper
   # The default is UnderscoredAndPluralized.
   # You assign a naming convention like so:
   #
-  #   repository(:default).adapter.resource_naming_convention = NamingConventions::Underscored
+  #   repository(:default).adapter.resource_naming_convention = NamingConventions::Resource::Underscored
   #
   # You can also easily assign a custom convention with a Proc:
   #
@@ -21,32 +21,64 @@ module DataMapper
   # use code like this:
   #
   #   adapter = DataMapper.setup(:default, "mock://localhost/mock")
-  #   adapter.resource_naming_convention = DataMapper::NamingConventions::Underscored
+  #   adapter.resource_naming_convention = DataMapper::NamingConventions::Resource::Underscored
   module NamingConventions
 
-    module UnderscoredAndPluralized
-      def self.call(value)
-        Extlib::Inflection.pluralize(Extlib::Inflection.underscore(value)).gsub('/','_')
-      end
-    end # module UnderscoredAndPluralized
-
-    module UnderscoredAndPluralizedWithoutModule
-      def self.call(value)
-        Extlib::Inflection.pluralize(Extlib::Inflection.underscore(Extlib::Inflection.demodulize(value)))
-      end
-    end # module UnderscoredAndPluralizedWithoutModule
-
-    module Underscored
-      def self.call(value)
-        Extlib::Inflection.underscore(value)
-      end
-    end # module Underscored
-
-    module Yaml
-      def self.call(value)
-        Extlib::Inflection.pluralize(Extlib::Inflection.underscore(value)) + ".yaml"
-      end
-    end # module Yaml
+    module Resource
+
+      module UnderscoredAndPluralized
+        def self.call(name)
+          Extlib::Inflection.pluralize(Extlib::Inflection.underscore(name)).gsub('/','_')
+        end
+      end # module UnderscoredAndPluralized
+
+      module UnderscoredAndPluralizedWithoutModule
+        def self.call(name)
+          Extlib::Inflection.pluralize(Extlib::Inflection.underscore(Extlib::Inflection.demodulize(name)))
+        end
+      end # module UnderscoredAndPluralizedWithoutModule
+
+      module Underscored
+        def self.call(name)
+          Extlib::Inflection.underscore(name)
+        end
+      end # module Underscored
+
+      module Yaml
+        def self.call(name)
+          Extlib::Inflection.pluralize(Extlib::Inflection.underscore(name)) + ".yaml"
+        end
+      end # module Yaml
+
+    end # module Resource
+
+    module Field
+
+      module UnderscoredAndPluralized
+        def self.call(property)
+          Extlib::Inflection.pluralize(Extlib::Inflection.underscore(property.name.to_s)).gsub('/','_')
+        end
+      end # module UnderscoredAndPluralized
+
+      module UnderscoredAndPluralizedWithoutModule
+        def self.call(property)
+          Extlib::Inflection.pluralize(Extlib::Inflection.underscore(Extlib::Inflection.demodulize(property.name.to_s)))
+        end
+      end # module UnderscoredAndPluralizedWithoutModule
+
+      module Underscored
+        def self.call(property)
+          Extlib::Inflection.underscore(property.name.to_s)
+        end
+      end # module Underscored
+
+      module Yaml
+        def self.call(property)
+          Extlib::Inflection.pluralize(Extlib::Inflection.underscore(property.name.to_s)) + ".yaml"
+        end
+      end # module Yaml
+
+    end # module Field
 
   end # module NamingConventions
 end # module DataMapper

data/lib/dm-core/property.rb

@@ -279,7 +279,7 @@ module DataMapper
 
     attr_reader :primitive, :model, :name, :instance_variable_name,
       :type, :reader_visibility, :writer_visibility, :getter, :options,
-      :default, :precision, :scale, :track
+      :default, :precision, :scale, :track, :extra_options
 
     # Supplies the field in the data-store which the property corresponds to
     #
@@ -510,8 +510,9 @@ module DataMapper
         raise ArgumentError, "+type+ was #{type.inspect}, which is not a supported type: #{TYPES * ', '}", caller
       end
 
-      if (unknown_options = options.keys - PROPERTY_OPTIONS).any?
-        raise ArgumentError, "+options+ contained unknown keys: #{unknown_options * ', '}", caller
+      @extra_options = {}
+      (options.keys - PROPERTY_OPTIONS).each do |key|
+        @extra_options[key] = options.delete(key)
       end
 
       @model                  = model
@@ -548,7 +549,7 @@ module DataMapper
         @length = @options.fetch(:length, @options.fetch(:size, DEFAULT_LENGTH))
       elsif BigDecimal == @primitive || Float == @primitive
         @precision = @options.fetch(:precision, DEFAULT_PRECISION)
-        
+
         default_scale = (Float == @primitive) ? DEFAULT_SCALE_FLOAT : DEFAULT_SCALE_BIGDECIMAL
         @scale     = @options.fetch(:scale, default_scale)
         # @scale     = @options.fetch(:scale, DEFAULT_SCALE_BIGDECIMAL)
@@ -575,7 +576,7 @@ module DataMapper
     end
 
     def fields
-      @fields ||= Hash.new { |h,k| h[k] = repository(k).adapter.field_naming_convention.call(self.name) }
+      @fields ||= Hash.new { |h,k| h[k] = self.model.field_naming_conventions[k].call(self) }
     end
 
     def determine_visibility # :nodoc:

data/lib/dm-core/query.rb

@@ -47,7 +47,7 @@ module DataMapper
       # only overwrite the attributes with non-default values
       @reload       = other.reload?       unless other.reload?       == false
       @unique       = other.unique?       unless other.unique?       == false
-      @offset       = other.offset        unless other.offset        == 0
+      @offset       = other.offset        if other.reload? || other.offset != 0
       @limit        = other.limit         unless other.limit         == nil
       @order        = other.order         unless other.order         == model.default_order
       @add_reversed = other.add_reversed? unless other.add_reversed? == false
@@ -189,8 +189,6 @@ module DataMapper
       @links    = normalize_links(@links)
       @includes = normalize_includes(@includes)
 
-      translate_custom_types(@properties, options)
-
       # treat all non-options as conditions
       (options.keys - OPTIONS - OPTIONS.map { |option| option.to_s }).each do |k|
         append_condition(k, options[k])
@@ -218,17 +216,6 @@ module DataMapper
       @conditions = original.conditions.map { |tuple| tuple.dup }
     end
 
-    def translate_custom_types(properties, options)
-      options.each do |key, value|
-        case key
-          when DataMapper::Query::Operator
-            options[key] = properties[key.target].type.dump(value, properties[key.target]) if properties.has_property?(key.target) && properties[key.target].custom?
-          when Symbol, String
-            options[key] = properties[key].type.dump(value, properties[key]) if properties.has_property?(key) && properties[key].custom?
-        end
-      end
-    end
-
     # validate the options
     def assert_valid_options(options)
       # validate the reload option and unique option
@@ -440,9 +427,26 @@ module DataMapper
         raise ArgumentError, "Clause #{clause.inspect} does not map to a DataMapper::Property", caller(2)
       end
 
+      bind_value = dump_custom_value(property, bind_value)
+
       @conditions << [ operator, property, bind_value ]
     end
 
+    def dump_custom_value(property_or_path, bind_value)
+      case property_or_path
+      when DataMapper::Query::Path
+        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) 
+        else
+          bind_value
+        end
+      else
+        bind_value
+      end
+    end
+
     # TODO: check for other mutually exclusive operator + property
     # combinations.  For example if self's conditions were
     # [ :gt, :amount, 5 ] and the other's condition is [ :lt, :amount, 2 ]
@@ -565,8 +569,8 @@ module DataMapper
 
     class Path
       include Assertions
-			
-			%w[ id type ].each { |m| undef_method m }
+
+   %w[ id type ].each { |m| undef_method m }
 
       attr_reader :relationships, :model, :property, :operator
 

data/lib/dm-core/resource.rb

@@ -167,6 +167,17 @@ module DataMapper
 
     alias == eql?
 
+    # Computes a hash for the resource
+    #
+    # ==== Returns
+    # <Integer>:: the hash value of the resource
+    #
+    # -
+    # @api public
+    def hash
+      model.hash + key.hash
+    end
+
     # Inspection of the class name and the attributes
     #
     # ==== Returns
@@ -233,7 +244,7 @@ module DataMapper
 
     def key
       key_properties.map do |property|
-        property.get!(self)
+        original_values[property.name] || property.get!(self)
       end
     end
 
@@ -259,19 +270,22 @@ module DataMapper
       # same API through out all of dm-more. dm-validations requires a
       # context to be passed
 
-      child_associations.each { |a| a.save }
+      associations_saved = false
+      child_associations.each { |a| associations_saved |= a.save }
 
-      success = if dirty? || (new_record? && key_properties.any? { |p| p.serial? })
+      saved = if dirty? || (new_record? && key_properties.any? { |p| p.serial? })
         new_record? ? create : update
       end
 
-      if success
+      if saved
         original_values.clear
       end
 
-      parent_associations.each { |a| a.save }
+      parent_associations.each { |a| associations_saved |= a.save }
 
-      success == true
+      # We should return true if the model (or any of its associations)
+      # were saved.
+      (saved | associations_saved) == true
     end
 
     # destroy the instance, remove it from the repository
@@ -503,7 +517,10 @@ module DataMapper
     #-
     # @api public
     def update_attributes(hash, *update_only)
-      raise 'Update takes a hash as first parameter' unless hash.is_a?(Hash)
+      unless hash.is_a?(Hash)
+        raise ArgumentError, "Expecting the first parameter of " +
+          "update_attributes to be a hash; got #{hash.inspect}"
+      end
       loop_thru = update_only.empty? ? hash.keys : update_only
       loop_thru.each { |attr|  send("#{attr}=", hash[attr]) }
       save

data/lib/dm-core/version.rb

@@ -1,3 +1,3 @@
 module DataMapper
-  VERSION = '0.9.3' unless defined?(DataMapper::VERSION)
+  VERSION = '0.9.4' unless defined?(DataMapper::VERSION)
 end

data/script/performance.rb

@@ -23,6 +23,7 @@ socket_file = Pathname.glob(%w[
   tmp/mysql.sock
   /tmp/mysql.sock
   /var/mysql/mysql.sock
+  /var/run/mysqld/mysqld.sock
 ]).find { |path| path.socket? }
 
 configuration_options = {
@@ -130,7 +131,7 @@ puts "Benchmarks will now run #{TIMES} times"
 RBench.run(TIMES) do
 
   column :times
-  column :dm, :title => "DM 0.9.3"
+  column :dm, :title => "DM 0.9.4"
   column :ar, :title => "AR 2.1"
   column :diff, :compare => [:dm,:ar]
 

data/script/profile.rb

@@ -18,6 +18,7 @@ SOCKET_FILE = Pathname.glob(%w[
   /tmp/mysqld.sock
   /tmp/mysql.sock
   /var/mysql/mysql.sock
+  /var/run/mysqld/mysqld.sock
 ]).find { |path| path.socket? }
 
 DataMapper::Logger.new(DataMapper.root / 'log' / 'dm.log', :debug)

data/spec/integration/association_spec.rb

@@ -165,6 +165,19 @@ if ADAPTER
       belongs_to :parent, :class_name => 'Node', :child_key => [ :parent_id ]
     end
 
+    class MadeUpThing
+      include DataMapper::Resource
+
+      def self.default_repository_name
+        ADAPTER
+      end
+
+      property :id, Serial
+      property :name, String
+      belongs_to :area
+      belongs_to :machine
+    end
+
     module Models
       class Project
         include DataMapper::Resource
@@ -227,6 +240,7 @@ if ADAPTER
 
       belongs_to :galaxy
     end
+
   end
 
   describe DataMapper::Associations do
@@ -274,6 +288,7 @@ if ADAPTER
       before do
         Machine.auto_migrate!(ADAPTER)
         Area.auto_migrate!(ADAPTER)
+        MadeUpThing.auto_migrate!(ADAPTER)
 
         machine1 = Machine.create(:name => 'machine1')
         machine2 = Machine.create(:name => 'machine2')
@@ -299,10 +314,9 @@ if ADAPTER
       end
 
       it 'should save both the object and parent if both are new' do
-        pending "This is fixed"
         area1 = Area.new(:name => 'area1')
         area1.machine = Machine.new(:name => 'machine1')
-        area1.machine.save
+        area1.save
         area1.machine_id.should == area1.machine.id
       end
 
@@ -338,6 +352,16 @@ if ADAPTER
         Area.new(:machine => machine).machine_id.should == machine.id
       end
 
+      it "should be able to set an association obtained from another association" do
+        machine1 = Machine.first(:name => 'machine1')
+        area1 = Area.first(:name => 'area1')
+        area1.machine = machine1
+
+        m = MadeUpThing.create(:machine => area1.machine, :name => "Weird")
+
+        m.machine_id.should == machine1.id
+      end
+
       it 'should save the parent upon saving of child' do
         e = Machine.new(:name => 'machine10')
         y = Area.create(:name => 'area10', :machine => e)
@@ -346,6 +370,13 @@ if ADAPTER
         Machine.first(:name => 'machine10').should_not be_nil
       end
 
+      it 'should set and retrieve associations on not yet saved objects' do
+        e = Machine.create(:name => 'machine10')
+        y = e.areas.build(:name => 'area10')
+
+        y.machine.name.should == 'machine10'
+      end
+
       it 'should convert NULL parent ids into nils' do
         Area.first(:name => 'area2').machine.should be_nil
       end
@@ -379,6 +410,17 @@ if ADAPTER
 
         lambda { y.reload }.should_not raise_error
       end
+
+      it "should have machine when created using machine_id" do
+        m = Machine.create(:name => 'machineX')
+        a = Area.new(:machine_id => m.id)
+        a.machine.should == m
+      end
+      
+      it "should not have a machine when orphaned" do
+        a = Area.new(:machine_id => 42)
+        a.machine.should be_nil
+      end
     end
 
     describe 'one to one associations' do
@@ -697,7 +739,7 @@ if ADAPTER
               end
               property :id, Serial
               property :name, String
-              belongs_to :shop, :class_name => 'Sweets::Shop'
+              belongs_to :shop
               has 1, :wife
               has n, :children
               has n, :toys,     :through => :children
@@ -1178,18 +1220,19 @@ if ADAPTER
         @li = LeftItem.new(:name => "li#{number}")
       end
 
-      it "should add to the assocaiton from the left" do
-        pending "Waiting on Many To Many to be implemented"
-        create_item_pair "0000"
-        @ri.save; @li.save
-        @ri.should_not be_new_record
-        @li.should_not be_new_record
+      it "should add to the association from the left" do
+        pending "Waiting on Many To Many to be implemented" do
+          create_item_pair "0000"
+          @ri.save; @li.save
+          @ri.should_not be_new_record
+          @li.should_not be_new_record
 
-        @li.right_items << @ri
-        @li.right_items.should include(@ri)
-        @li.reload
-        @ri.reload
-        @li.right_items.should include(@ri)
+          @li.right_items << @ri
+          @li.right_items.should include(@ri)
+          @li.reload
+          @ri.reload
+          @li.right_items.should include(@ri)
+        end
       end
 
       it "should add to the association from the right" do
@@ -1205,93 +1248,100 @@ if ADAPTER
         @ri.left_items.should include(@li)
       end
 
-      it "should load the assocaited collection from the either side" do
-        pending "Waiting on Many To Many to be implemented"
-        create_item_pair "0020"
-        @ri.save; @li.save
-        @ri.left_items << @li
-        @ri.reload; @li.reload
+      it "should load the associated collection from the either side" do
+        pending "Waiting on Many To Many to be implemented" do
+          create_item_pair "0020"
+          @ri.save; @li.save
+          @ri.left_items << @li
+          @ri.reload; @li.reload
 
-        @ri.left_items.should include(@li)
-        @li.right_items.should include(@ri)
+          @ri.left_items.should include(@li)
+          @li.right_items.should include(@ri)
+        end
       end
 
-      it "should load the assocatied collection from the right" do
-        pending "Waiting on Many To Many to be implemented"
-        create_item_pair "0030"
-        @ri.save; @li.save
-        @li.right_items << @li
-        @ri.reload; @li.reload
-
-        @ri.left_items.should include(@li)
-        @li.right_items.should include(@ri)
+      it "should load the associated collection from the right" do
+        pending "Waiting on Many To Many to be implemented" do
+          create_item_pair "0030"
+          @ri.save; @li.save
+          @li.right_items << @li
+          @ri.reload; @li.reload
 
+          @ri.left_items.should include(@li)
+          @li.right_items.should include(@ri)
+        end
       end
 
       it "should save the left side of the association if new record" do
-        pending "Waiting on Many To Many to be implemented"
-        create_item_pair "0040"
-        @ri.save
-        @li.should be_new_record
-        @ri.left_items << @li
-        @li.should_not be_new_record
+        pending "Waiting on Many To Many to be implemented" do
+          create_item_pair "0040"
+          @ri.save
+          @li.should be_new_record
+          @ri.left_items << @li
+          @li.should_not be_new_record
+        end
       end
 
-      it "should save the right side of the assocaition if new record" do
-        pending "Waiting on Many To Many to be implemented"
-        create_item_pair "0050"
-        @li.save
-        @ri.should be_new_record
-        @li.right_items << @ri
-        @ri.should_not be_new_record
+      it "should save the right side of the association if new record" do
+        pending "Waiting on Many To Many to be implemented" do
+          create_item_pair "0050"
+          @li.save
+          @ri.should be_new_record
+          @li.right_items << @ri
+          @ri.should_not be_new_record
+        end
       end
 
-      it "should save both side of the assocaition if new record" do
-        pending "Waiting on Many To Many to be implemented"
-        create_item_pair "0060"
-        @li.should be_new_record
-        @ri.should be_new_record
-        @ri.left_items << @li
-        @ri.should_not be_new_record
-        @li.should_not be_new_record
+      it "should save both side of the association if new record" do
+        pending "Waiting on Many To Many to be implemented" do
+          create_item_pair "0060"
+          @li.should be_new_record
+          @ri.should be_new_record
+          @ri.left_items << @li
+          @ri.should_not be_new_record
+          @li.should_not be_new_record
+        end
       end
 
       it "should remove an item from the left collection without destroying the item" do
-        pending "Waiting on Many To Many to be implemented"
-        create_item_pair "0070"
-        @li.save; @ri.save
-        @ri.left_items << @li
-        @ri.reload; @li.reload
-        @ri.left_items.should include(@li)
-        @ri.left_items.delete(@li)
-        @ri.left_items.should_not include(@li)
-        @li.reload
-        LeftItem.get(@li.id).should_not be_nil
+        pending "Waiting on Many To Many to be implemented" do
+          create_item_pair "0070"
+          @li.save; @ri.save
+          @ri.left_items << @li
+          @ri.reload; @li.reload
+          @ri.left_items.should include(@li)
+          @ri.left_items.delete(@li)
+          @ri.left_items.should_not include(@li)
+          @li.reload
+          LeftItem.get(@li.id).should_not be_nil
+        end
       end
 
       it "should remove an item from the right collection without destroying the item" do
-        pending "Waiting on Many To Many to be implemented"
-        create_item_pair "0080"
-        @li.save; @ri.save
-        @li.right_items << @ri
-        @li.reload; @ri.reload
-        @li.right_items.should include(@ri)
-        @li.right_items.delete(@ri)
-        @li.right_items.should_not include(@ri)
-        @ri.reload
-        RightItem.get(@ri.id).should_not be_nil
+        pending "Waiting on Many To Many to be implemented" do
+          create_item_pair "0080"
+          @li.save; @ri.save
+          @li.right_items << @ri
+          @li.reload; @ri.reload
+          @li.right_items.should include(@ri)
+          @li.right_items.delete(@ri)
+          @li.right_items.should_not include(@ri)
+          @ri.reload
+          RightItem.get(@ri.id).should_not be_nil
+        end
       end
 
       it "should remove the item from the collection when an item is deleted" do
-        pending "Waiting on Many To Many to be implemented"
-        create_item_pair "0090"
-        @li.save; @ri.save
-        @ri.left_items << @li
-        @ri.reload; @li.reload
-        @ri.left_items.should include(@li)
-        @li.destroy
-        @ri.reload
-        @ri.left_items.should_not include(@li)
+        pending "Waiting on Many To Many to be implemented" do
+          create_item_pair "0090"
+          @li.save; @ri.save
+          @ri.left_items << @li
+          @ri.reload; @li.reload
+          @ri.left_items.should include(@li)
+          @li.destroy
+          @ri.reload
+          @ri.left_items.should_not include(@li)
+        end
       end
     end
   end