dm-core 0.10.1 → 0.10.2

data/lib/dm-core/spec/adapter_shared_spec.rb

@@ -173,6 +173,21 @@ share_examples_for 'An Adapter' do
             Heffalump.all(:color.not => nil).should_not be_include(@two)
           end
 
+          it 'should be able to search for object with a nil value using required properties' do
+            Heffalump.all(:id.not => nil).should == [ @red, @two, @five ]
+          end
+
+          it 'should be able to search for objects not in an empty list (match all)' do
+            Heffalump.all(:color.not => []).should == [ @red, @two, @five ]
+          end
+
+          it 'should be able to search for objects in an empty list and another OR condition (match none on the empty list)' do
+            Heffalump.all(:conditions => DataMapper::Query::Conditions::Operation.new(
+                                           :or,
+                                           DataMapper::Query::Conditions::Comparison.new(:in, Heffalump.properties[:color], []),
+                                           DataMapper::Query::Conditions::Comparison.new(:in, Heffalump.properties[:num_spots], [5]))).should == [ @five ]
+          end
+
           it 'should be able to search for objects not included in an array of values' do
             Heffalump.all(:num_spots.not => [ 1, 3, 5, 7 ]).should be_include(@two)
           end
@@ -210,7 +225,8 @@ share_examples_for 'An Adapter' do
 
         describe 'regexp' do
           before do
-            if defined?(DataMapper::Adapters::Sqlite3Adapter) && @adapter.kind_of?(DataMapper::Adapters::Sqlite3Adapter)
+            if (defined?(DataMapper::Adapters::Sqlite3Adapter) && @adapter.kind_of?(DataMapper::Adapters::Sqlite3Adapter) ||
+                defined?(DataMapper::Adapters::SqlserverAdapter) && @adapter.kind_of?(DataMapper::Adapters::SqlserverAdapter))
               pending 'delegate regexp matches to same system that the InMemory and YAML adapters use'
             end
           end

data/lib/dm-core/spec/data_objects_adapter_shared_spec.rb

@@ -9,6 +9,13 @@ share_examples_for 'A DataObjects Adapter' do
 
     # set up the adapter after switching the logger so queries can be captured
     @adapter = DataMapper.setup(@adapter.name, @adapter.options)
+
+    @jruby = !!(RUBY_PLATFORM =~ /java/)
+
+    @postgres   = defined?(DataMapper::Adapters::PostgresAdapter)  && @adapter.kind_of?(DataMapper::Adapters::PostgresAdapter)
+    @mysql      = defined?(DataMapper::Adapters::MysqlAdapter)     && @adapter.kind_of?(DataMapper::Adapters::MysqlAdapter)
+    @sql_server = defined?(DataMapper::Adapters::SqlserverAdapter) && @adapter.kind_of?(DataMapper::Adapters::SqlserverAdapter)
+    @oracle     = defined?(DataMapper::Adapters::OracleAdapter)    && @adapter.kind_of?(DataMapper::Adapters::OracleAdapter)
   end
 
   after :all do
@@ -22,7 +29,7 @@ share_examples_for 'A DataObjects Adapter' do
 
   def log_output
     @log.rewind
-    @log.read.chomp.gsub(/^\s+~ \(\d+\.?\d*\)\s+/, '')
+    @log.read.chomp.gsub(/^\s+~ \(\d+\.?\d*\)\s+/, '').split("\n")
   end
 
   def supports_default_values?
@@ -40,11 +47,8 @@ share_examples_for 'A DataObjects Adapter' do
           include DataMapper::Resource
 
           property :id, Serial
-        end
 
-        # create all tables and constraints before each spec
-        if @repository.respond_to?(:auto_migrate!)
-          Article.auto_migrate!
+          auto_migrate!
         end
 
         reset_log
@@ -53,8 +57,10 @@ share_examples_for 'A DataObjects Adapter' do
       end
 
       it 'should not send NULL values' do
-        statement = if defined?(DataMapper::Adapters::MysqlAdapter) && @adapter.kind_of?(DataMapper::Adapters::MysqlAdapter)
+        statement = if @mysql
           /\AINSERT INTO `articles` \(\) VALUES \(\)\z/
+        elsif @oracle
+          /\AINSERT INTO "ARTICLES" \("ID"\) VALUES \(DEFAULT\) RETURNING "ID"/
         elsif supports_default_values? && supports_returning?
           /\AINSERT INTO "articles" DEFAULT VALUES RETURNING \"id\"\z/
         elsif supports_default_values?
@@ -63,7 +69,7 @@ share_examples_for 'A DataObjects Adapter' do
           /\AINSERT INTO "articles" \(\) VALUES \(\)\z/
         end
 
-        log_output.should =~ statement
+        log_output.first.should =~ statement
       end
     end
 
@@ -74,11 +80,8 @@ share_examples_for 'A DataObjects Adapter' do
 
           property :id,    Serial
           property :title, String
-        end
 
-        # create all tables and constraints before each spec
-        if @repository.respond_to?(:auto_migrate!)
-          Article.auto_migrate!
+          auto_migrate!
         end
 
         reset_log
@@ -87,20 +90,277 @@ share_examples_for 'A DataObjects Adapter' do
       end
 
       it 'should not send NULL values' do
-        if defined?(DataMapper::Adapters::MysqlAdapter) && @adapter.kind_of?(DataMapper::Adapters::MysqlAdapter)
-          log_output.should =~ /^INSERT INTO `articles` \(`id`\) VALUES \(.{1,2}\)$/i
+        regexp = if @mysql
+          /^INSERT INTO `articles` \(`id`\) VALUES \(.{1,2}\)$/i
+        elsif @sql_server
+          /^SET IDENTITY_INSERT \"articles\" ON INSERT INTO "articles" \("id"\) VALUES \(.{1,2}\) SET IDENTITY_INSERT \"articles\" OFF $/i
         else
-          log_output.should =~ /^INSERT INTO "articles" \("id"\) VALUES \(.{1,2}\)$/i
+          /^INSERT INTO "articles" \("id"\) VALUES \(.{1,2}\)$/i
         end
+
+        log_output.first.should =~ regexp
+      end
+    end
+  end
+
+  describe '#select' do
+    before :all do
+      class ::Article
+        include DataMapper::Resource
+
+        property :name,   String, :key => true
+        property :author, String, :required => true
+
+        auto_migrate!
+      end
+
+      @article_model = Article
+
+      @article_model.create(:name => 'Learning DataMapper', :author => 'Dan Kubb')
+    end
+
+    describe 'when one field specified in SELECT statement' do
+      before :all do
+        @return = @adapter.select('SELECT name FROM articles')
+      end
+
+      it 'should return an Array' do
+        @return.should be_kind_of(Array)
+      end
+
+      it 'should have a single result' do
+        @return.size.should == 1
+      end
+
+      it 'should return an Array of values' do
+        @return.should == [ 'Learning DataMapper' ]
+      end
+    end
+
+    describe 'when more than one field specified in SELECT statement' do
+      before :all do
+        @return = @adapter.select('SELECT name, author FROM articles')
+      end
+
+      it 'should return an Array' do
+        @return.should be_kind_of(Array)
+      end
+
+      it 'should have a single result' do
+        @return.size.should == 1
+      end
+
+      it 'should return an Array of Struct objects' do
+        @return.first.should be_kind_of(Struct)
+      end
+
+      it 'should return expected values' do
+        @return.first.values.should == [ 'Learning DataMapper', 'Dan Kubb' ]
       end
     end
   end
 
   describe '#execute' do
-    it 'should allow queries without return results'
+    before :all do
+      class ::Article
+        include DataMapper::Resource
+
+        property :name,   String, :key => true
+        property :author, String, :required => true
+
+        auto_migrate!
+      end
+
+      @article_model = Article
+    end
+
+    before :all do
+      @result = @adapter.execute('INSERT INTO articles (name, author) VALUES(?, ?)', 'Learning DataMapper', 'Dan Kubb')
+    end
+
+    it 'should return a DataObjects::Result' do
+      @result.should be_kind_of(DataObjects::Result)
+    end
+
+    it 'should affect 1 row' do
+      @result.affected_rows.should == 1
+    end
+
+    it 'should not have an insert_id' do
+      pending_if 'Inconsistent insert_id results', !(@postgres || @oracle || (@jruby && @mysql)) do
+        @result.insert_id.should be_nil
+      end
+    end
   end
 
-  describe '#query' do
-    it 'should allow queries with return results'
+  describe '#read' do
+    before :all do
+      class ::Article
+        include DataMapper::Resource
+
+        property :name, String, :key => true
+
+        belongs_to :parent, self, :required => false
+        has n, :children, self, :inverse => :parent
+
+        auto_migrate!
+      end
+
+      @article_model = Article
+    end
+
+    describe 'with a raw query' do
+      before :all do
+        @article_model.create(:name => 'Test').should be_saved
+
+        @query = DataMapper::Query.new(@repository, @article_model, :conditions => [ 'name IS NOT NULL' ])
+
+        @return = @adapter.read(@query)
+      end
+
+      it 'should return an Array of Hashes' do
+        @return.should be_kind_of(Array)
+        @return.all? { |entry| entry.should be_kind_of(Hash) }
+      end
+
+      it 'should return expected values' do
+        @return.should == [ { @article_model.properties[:name] => 'Test', @article_model.properties[:parent_name] => nil } ]
+      end
+    end
+
+    describe 'with a raw query with a bind value mismatch' do
+      before :all do
+        @article_model.create(:name => 'Test').should be_saved
+
+        @query = DataMapper::Query.new(@repository, @article_model, :conditions => [ 'name IS NOT NULL', nil ])
+      end
+
+      it 'should raise an error' do
+        lambda {
+          @adapter.read(@query)
+        }.should raise_error(ArgumentError, 'Binding mismatch: 1 for 0')
+      end
+    end
+
+    describe 'with a Collection bind value' do
+      describe 'with an inclusion comparison' do
+        before :all do
+          5.times do |index|
+            @article_model.create(:name => "Test #{index}", :parent => @article_model.last).should be_saved
+          end
+
+          @parents = @article_model.all
+          @query   = DataMapper::Query.new(@repository, @article_model, :parent => @parents)
+
+          @expected = @article_model.all[1, 4].map { |article| article.attributes(:property) }
+        end
+
+        describe 'that is not loaded' do
+          before :all do
+            reset_log
+            @return = @adapter.read(@query)
+          end
+
+          it 'should return an Array of Hashes' do
+            @return.should be_kind_of(Array)
+            @return.all? { |entry| entry.should be_kind_of(Hash) }
+          end
+
+          it 'should return expected values' do
+            @return.should == @expected
+          end
+
+          it 'should execute one subquery' do
+            pending_if @mysql do
+              log_output.size.should == 1
+            end
+          end
+        end
+
+        describe 'that is loaded' do
+          before :all do
+            @parents.to_a  # lazy load the collection
+          end
+
+          before :all do
+            reset_log
+            @return = @adapter.read(@query)
+          end
+
+          it 'should return an Array of Hashes' do
+            @return.should be_kind_of(Array)
+            @return.all? { |entry| entry.should be_kind_of(Hash) }
+          end
+
+          it 'should return expected values' do
+            @return.should == @expected
+          end
+
+          it 'should execute one query' do
+            log_output.size.should == 1
+          end
+        end
+      end
+
+      describe 'with an negated inclusion comparison' do
+        before :all do
+          5.times do |index|
+            @article_model.create(:name => "Test #{index}", :parent => @article_model.last).should be_saved
+          end
+
+          @parents = @article_model.all
+          @query   = DataMapper::Query.new(@repository, @article_model, :parent.not => @parents)
+
+          @expected = []
+        end
+
+        describe 'that is not loaded' do
+          before :all do
+            reset_log
+            @return = @adapter.read(@query)
+          end
+
+          it 'should return an Array of Hashes' do
+            @return.should be_kind_of(Array)
+            @return.all? { |entry| entry.should be_kind_of(Hash) }
+          end
+
+          it 'should return expected values' do
+            @return.should == @expected
+          end
+
+          it 'should execute one subquery' do
+            pending_if @mysql do
+              log_output.size.should == 1
+            end
+          end
+        end
+
+        describe 'that is loaded' do
+          before :all do
+            @parents.to_a  # lazy load the collection
+          end
+
+          before :all do
+            reset_log
+            @return = @adapter.read(@query)
+          end
+
+          it 'should return an Array of Hashes' do
+            @return.should be_kind_of(Array)
+            @return.all? { |entry| entry.should be_kind_of(Hash) }
+          end
+
+          it 'should return expected values' do
+            @return.should == @expected
+          end
+
+          it 'should execute one query' do
+            log_output.size.should == 1
+          end
+        end
+      end
+
+    end
   end
 end

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

@@ -1,7 +1,6 @@
 module DataMapper
   module Chainable
 
-    # TODO: document
     # @api private
     def chainable(&block)
       mod = Module.new(&block)
@@ -9,7 +8,6 @@ module DataMapper
       mod
     end
 
-    # TODO: document
     # @api private
     def extendable(&block)
       mod = Module.new(&block)

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

@@ -1,21 +1,45 @@
 module DataMapper
   module Equalizer
     def equalize(*methods)
+      define_eql_method(methods)
+      define_equivalent_method(methods)
+      define_hash_method(methods)
+    end
+
+    private
+
+    def define_eql_method(methods)
       class_eval <<-RUBY, __FILE__, __LINE__ + 1
         def eql?(other)
           return true if equal?(other)
           instance_of?(other.class) &&
           #{methods.map { |method| "#{method}.eql?(other.#{method})" }.join(' && ')}
         end
+      RUBY
+    end
+
+    def define_equivalent_method(methods)
+      respond_to = []
+      equivalent = []
 
+      methods.each do |method|
+        respond_to << "other.respond_to?(#{method.inspect})"
+        equivalent << "#{method} == other.#{method}"
+      end
+
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
         def ==(other)
           return true if equal?(other)
-          #{methods.map { |method| "other.respond_to?(#{method.inspect})" }.join(' && ')} &&
-          #{methods.map { |method| "#{method} == other.#{method}" }.join(' && ')}
+          #{respond_to.join(' && ')} &&
+          #{equivalent.join(' && ')}
         end
+      RUBY
+    end
 
+    def define_hash_method(methods)
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
         def hash
-          [ #{methods.join(', ')} ].hash
+          #{methods.map { |method| "#{method}.hash" }.join(' ^ ')}
         end
       RUBY
     end

data/lib/dm-core/transaction.rb

@@ -4,6 +4,29 @@ module DataMapper
   class Transaction
     extend Chainable
 
+    # @api private
+    attr_accessor :state
+
+    # @api private
+    def none?
+      state == :none
+    end
+
+    # @api private
+    def begin?
+      state == :begin
+    end
+
+    # @api private
+    def rollback?
+      state == :rollback
+    end
+
+    # @api private
+    def commit?
+      state == :commit
+    end
+
     # Create a new Transaction
     #
     # @see Transaction#link
@@ -14,7 +37,7 @@ module DataMapper
     # @api public
     def initialize(*things)
       @transaction_primitives = {}
-      @state = :none
+      self.state = :none
       @adapters = {}
       link(*things)
       if block_given?
@@ -44,8 +67,8 @@ module DataMapper
     #
     # @api private
     def link(*things)
-      unless @state == :none
-        raise "Illegal state for link: #{@state}"
+      unless none?
+        raise "Illegal state for link: #{state}"
       end
 
       things.each do |thing|
@@ -78,13 +101,13 @@ module DataMapper
     #
     # @api private
     def begin
-      unless @state == :none
-        raise "Illegal state for begin: #{@state}"
+      unless none?
+        raise "Illegal state for begin: #{state}"
       end
 
       each_adapter(:connect_adapter, [:log_fatal_transaction_breakage])
       each_adapter(:begin_adapter, [:rollback_and_close_adapter_if_begin, :close_adapter_if_none])
-      @state = :begin
+      self.state = :begin
     end
 
     # Commit the transaction
@@ -99,30 +122,33 @@ module DataMapper
     # @api private
     def commit
       if block_given?
-        unless @state == :none
-          raise "Illegal state for commit with block: #{@state}"
+        unless none?
+          raise "Illegal state for commit with block: #{state}"
         end
 
         begin
           self.begin
           rval = within { |*block_args| yield(*block_args) }
-          if @state == :begin
-            self.commit
-          end
-          return rval
         rescue Exception => exception
-          if @state == :begin
-            self.rollback
+          if begin?
+            rollback
           end
           raise exception
+        ensure
+          unless exception
+            if begin?
+              commit
+            end
+            return rval
+          end
         end
       else
-        unless @state == :begin
-          raise "Illegal state for commit without block: #{@state}"
+        unless begin?
+          raise "Illegal state for commit without block: #{state}"
         end
         each_adapter(:commit_adapter, [:log_fatal_transaction_breakage])
         each_adapter(:close_adapter, [:log_fatal_transaction_breakage])
-        @state = :commit
+        self.state = :commit
       end
     end
 
@@ -132,12 +158,12 @@ module DataMapper
     #
     # @api private
     def rollback
-      unless @state == :begin
-        raise "Illegal state for rollback: #{@state}"
+      unless begin?
+        raise "Illegal state for rollback: #{state}"
       end
       each_adapter(:rollback_adapter_if_begin, [:rollback_and_close_adapter_if_begin, :close_adapter_if_none])
       each_adapter(:close_adapter_if_open, [:log_fatal_transaction_breakage])
-      @state = :rollback
+      self.state = :rollback
     end
 
     # Execute a block within this Transaction.
@@ -155,52 +181,41 @@ module DataMapper
         raise 'No block provided'
       end
 
-      unless @state == :begin
-        raise "Illegal state for within: #{@state}"
+      unless begin?
+        raise "Illegal state for within: #{state}"
       end
 
-      @adapters.each do |adapter, state|
+      adapters = @adapters
+
+      adapters.each_key do |adapter|
         adapter.push_transaction(self)
       end
 
       begin
         yield self
       ensure
-        @adapters.each do |adapter, state|
+        adapters.each_key do |adapter|
           adapter.pop_transaction
         end
       end
     end
 
-    # TODO: document
     # @api private
-    def method_missing(meth, *args, &block)
-      if args.size == 1 && args.first.kind_of?(Adapters::AbstractAdapter)
-        if (match = meth.to_s.match(/^(.*)_if_(none|begin|rollback|commit)$/))
-          if self.respond_to?(match[1], true)
-            if state_for(args.first).to_s == match[2]
-              self.send(match[1], args.first)
-            end
-          else
-            super
-          end
-        elsif (match = meth.to_s.match(/^(.*)_unless_(none|begin|rollback|commit)$/))
-          if self.respond_to?(match[1], true)
-            unless state_for(args.first).to_s == match[2]
-              self.send(match[1], args.first)
-            end
-          else
-            super
-          end
-        else
-          super
-        end
-      else
-        super
-      end
+    def method_missing(method, *args, &block)
+      first_arg = args.first
+
+      return super unless args.size == 1 && first_arg.kind_of?(Adapters::AbstractAdapter)
+      return super unless match = method.to_s.match(/\A(.*)_(if|unless)_(none|begin|rollback|commit)\z/)
+
+      action, condition, expected_state = match.captures
+      return super unless respond_to?(action, true)
+
+      state   = state_for(first_arg).to_s
+      execute = (condition == 'if') == (state == expected_state)
+
+      send(action, first_arg) if execute
     end
 
-    # TODO: document
     # @api private
     def primitive_for(adapter)
       unless @adapters.include?(adapter)
@@ -216,7 +231,6 @@ module DataMapper
 
     private
 
-    # TODO: document
     # @api private
     def validate_primitive(primitive)
       [:close, :begin, :rollback, :commit].each do |meth|
@@ -228,18 +242,18 @@ module DataMapper
       primitive
     end
 
-    # TODO: document
     # @api private
     def each_adapter(method, on_fail)
+      adapters = @adapters
       begin
-        @adapters.each do |adapter, state|
-          self.send(method, adapter)
+        adapters.each_key do |adapter|
+          send(method, adapter)
         end
       rescue Exception => exception
-        @adapters.each do |adapter, state|
+        adapters.each_key do |adapter|
           on_fail.each do |fail_handler|
             begin
-              self.send(fail_handler, adapter)
+              send(fail_handler, adapter)
             rescue Exception => inner_exception
               DataMapper.logger.fatal("#{self}#each_adapter(#{method.inspect}, #{on_fail.inspect}) failed with #{exception.inspect}: #{exception.backtrace.join("\n")} - and when sending #{fail_handler} to #{adapter} we failed again with #{inner_exception.inspect}: #{inner_exception.backtrace.join("\n")}")
             end
@@ -249,7 +263,6 @@ module DataMapper
       end
     end
 
-    # TODO: document
     # @api private
     def state_for(adapter)
       unless @adapters.include?(adapter)
@@ -259,15 +272,16 @@ module DataMapper
       @adapters[adapter]
     end
 
-    # TODO: document
     # @api private
     def do_adapter(adapter, what, prerequisite)
       unless @transaction_primitives.include?(adapter)
         raise "No primitive for #{adapter}"
       end
 
-      unless state_for(adapter) == prerequisite
-        raise "Illegal state for #{what}: #{state_for(adapter)}"
+      state = state_for(adapter)
+
+      unless state == prerequisite
+        raise "Illegal state for #{what}: #{state}"
       end
 
       DataMapper.logger.debug("#{adapter.name}: #{what}")
@@ -275,13 +289,11 @@ module DataMapper
       @adapters[adapter] = what
     end
 
-    # TODO: document
     # @api private
     def log_fatal_transaction_breakage(adapter)
       DataMapper.logger.fatal("#{self} experienced a totally broken transaction execution. Presenting member #{adapter.inspect}.")
     end
 
-    # TODO: document
     # @api private
     def connect_adapter(adapter)
       if @transaction_primitives.key?(adapter)
@@ -291,7 +303,6 @@ module DataMapper
       @transaction_primitives[adapter] = validate_primitive(adapter.transaction_primitive)
     end
 
-    # TODO: document
     # @api private
     def close_adapter_if_open(adapter)
       if @transaction_primitives.include?(adapter)
@@ -299,7 +310,6 @@ module DataMapper
       end
     end
 
-    # TODO: document
     # @api private
     def close_adapter(adapter)
       unless @transaction_primitives.include?(adapter)
@@ -310,25 +320,21 @@ module DataMapper
       @transaction_primitives.delete(adapter)
     end
 
-    # TODO: document
     # @api private
     def begin_adapter(adapter)
       do_adapter(adapter, :begin, :none)
     end
 
-    # TODO: document
     # @api private
     def commit_adapter(adapter)
       do_adapter(adapter, :commit, :begin)
     end
 
-    # TODO: document
     # @api private
     def rollback_adapter(adapter)
       do_adapter(adapter, :rollback, :begin)
     end
 
-    # TODO: document
     # @api private
     def rollback_and_close_adapter(adapter)
       rollback_adapter(adapter)
@@ -338,7 +344,6 @@ module DataMapper
     module Adapter
       extend Chainable
 
-      # TODO: document
       # @api private
       def self.included(base)
         [ :Repository, :Model, :Resource ].each do |name|
@@ -402,13 +407,11 @@ module DataMapper
       chainable do
         protected
 
-        # TODO: document
         # @api semipublic
         def open_connection
           current_connection || super
         end
 
-        # TODO: document
         # @api semipublic
         def close_connection(connection)
           unless current_connection == connection
@@ -419,7 +422,6 @@ module DataMapper
 
       private
 
-      # TODO: document
       # @api private
       def transactions
         Thread.current[:dm_transactions] ||= []
@@ -439,7 +441,7 @@ module DataMapper
     end # module Adapter
 
     # alias the MySQL, PostgreSQL, Sqlite3 and Oracle adapters to use transactions
-    MysqlAdapter = PostgresAdapter = Sqlite3Adapter = OracleAdapter = Adapter
+    MysqlAdapter = PostgresAdapter = Sqlite3Adapter = OracleAdapter = SqlserverAdapter = Adapter
 
     module Repository
 
@@ -456,7 +458,6 @@ module DataMapper
     end # module Repository
 
     module Model
-      # TODO: document
       # @api private
       def self.included(mod)
         mod.descendants.each { |model| model.extend self }
@@ -493,7 +494,6 @@ module DataMapper
   module Adapters
     extendable do
 
-      # TODO: document
       # @api private
       def const_added(const_name)
         if Transaction.const_defined?(const_name)