datamapper-dm-core 0.9.11 → 0.10.0

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

@@ -0,0 +1,294 @@
+share_examples_for 'An Adapter' do
+
+  def self.adapter_supports?(*methods)
+    methods.all? do |method|
+      # TODO: figure out a way to see if the instance method is only inherited
+      # from the Abstract Adapter, and not defined in it's class.  If that is
+      # the case return false
+
+      # CRUD methods can be inherited from parent class
+      described_type.instance_methods.any? { |instance_method| method.to_s == instance_method.to_s }
+    end
+  end
+
+  before :all do
+    raise '+@adapter+ should be defined in before block' unless instance_variable_get('@adapter')
+
+    class ::Heffalump
+      include DataMapper::Resource
+
+      property :id,        Serial
+      property :color,     String
+      property :num_spots, Integer
+      property :striped,   Boolean
+    end
+
+    # create all tables and constraints before each spec
+    if @repository.respond_to?(:auto_migrate!)
+      Heffalump.auto_migrate!
+    end
+  end
+
+  if adapter_supports?(:create)
+    describe '#create' do
+      it 'should not raise any errors' do
+        lambda {
+          Heffalump.create(:color => 'peach')
+        }.should_not raise_error
+      end
+
+      it 'should set the identity field for the resource' do
+        heffalump = Heffalump.new(:color => 'peach')
+        heffalump.id.should be_nil
+        heffalump.save
+        heffalump.id.should_not be_nil
+      end
+    end
+  else
+    it 'needs to support #create'
+  end
+
+  if adapter_supports?(:read)
+    describe '#read' do
+      before :all do
+        @heffalump = Heffalump.create(:color => 'brownish hue')
+        #just going to borrow this, so I can check the return values
+        @query = Heffalump.all.query
+      end
+
+      it 'should not raise any errors' do
+        lambda {
+          Heffalump.all()
+        }.should_not raise_error
+      end
+
+      it 'should return stuff' do
+        Heffalump.all.should be_include(@heffalump)
+      end
+    end
+  else
+    it 'needs to support #read'
+  end
+
+  if adapter_supports?(:update)
+    describe '#update' do
+      before do
+        @heffalump = Heffalump.create(:color => 'indigo')
+      end
+
+      it 'should not raise any errors' do
+        lambda {
+          @heffalump.color = 'violet'
+          @heffalump.save
+        }.should_not raise_error
+      end
+
+      it 'should not alter the identity field' do
+        id = @heffalump.id
+        @heffalump.color = 'violet'
+        @heffalump.save
+        @heffalump.id.should == id
+      end
+
+      it 'should update altered fields' do
+        @heffalump.color = 'violet'
+        @heffalump.save
+        Heffalump.get(*@heffalump.key).color.should == 'violet'
+      end
+
+      it 'should not alter other fields' do
+        color = @heffalump.color
+        @heffalump.num_spots = 3
+        @heffalump.save
+        Heffalump.get(*@heffalump.key).color.should == color
+      end
+    end
+  else
+    it 'needs to support #update'
+  end
+
+  if adapter_supports?(:delete)
+    describe '#delete' do
+      before do
+        @heffalump = Heffalump.create(:color => 'forest green')
+      end
+
+      it 'should not raise any errors' do
+        lambda {
+          @heffalump.destroy
+        }.should_not raise_error
+      end
+
+      it 'should delete the requested resource' do
+        id = @heffalump.id
+        @heffalump.destroy
+        Heffalump.get(id).should be_nil
+      end
+    end
+  else
+    it 'needs to support #delete'
+  end
+
+  if adapter_supports?(:read, :create)
+    describe 'query matching' do
+      before :all do
+        @red = Heffalump.create(:color => 'red')
+        @two = Heffalump.create(:num_spots => 2)
+        @five = Heffalump.create(:num_spots => 5)
+      end
+
+      describe 'conditions' do
+        describe 'eql' do
+          it 'should be able to search for objects included in an inclusive range of values' do
+            Heffalump.all(:num_spots => 1..5).should be_include(@five)
+          end
+
+          it 'should be able to search for objects included in an exclusive range of values' do
+            Heffalump.all(:num_spots => 1...6).should be_include(@five)
+          end
+
+          it 'should not be able to search for values not included in an inclusive range of values' do
+            Heffalump.all(:num_spots => 1..4).should_not be_include(@five)
+          end
+
+          it 'should not be able to search for values not included in an exclusive range of values' do
+            Heffalump.all(:num_spots => 1...5).should_not be_include(@five)
+          end
+        end
+
+        describe 'not' do
+          it 'should be able to search for objects with not equal value' do
+            Heffalump.all(:color.not => 'red').should_not be_include(@red)
+          end
+
+          it 'should include objects that are not like the value' do
+            Heffalump.all(:color.not => 'black').should be_include(@red)
+          end
+
+          it 'should be able to search for objects with not nil value' do
+            Heffalump.all(:color.not => nil).should be_include(@red)
+          end
+
+          it 'should not include objects with a nil value' do
+            Heffalump.all(:color.not => nil).should_not be_include(@two)
+          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
+
+          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_not be_include(@five)
+          end
+
+          it 'should be able to search for objects not included in an inclusive range of values' do
+            Heffalump.all(:num_spots.not => 1..4).should be_include(@five)
+          end
+
+          it 'should be able to search for objects not included in an exclusive range of values' do
+            Heffalump.all(:num_spots.not => 1...5).should be_include(@five)
+          end
+
+          it 'should not be able to search for values not included in an inclusive range of values' do
+            Heffalump.all(:num_spots.not => 1..5).should_not be_include(@five)
+          end
+
+          it 'should not be able to search for values not included in an exclusive range of values' do
+            Heffalump.all(:num_spots.not => 1...6).should_not be_include(@five)
+          end
+        end
+
+        describe 'like' do
+          it 'should be able to search for objects that match value' do
+            Heffalump.all(:color.like => '%ed').should be_include(@red)
+          end
+
+          it 'should not search for objects that do not match the value' do
+            Heffalump.all(:color.like => '%blak%').should_not be_include(@red)
+          end
+        end
+
+        describe 'regexp' do
+          before do
+            if defined?(DataMapper::Adapters::Sqlite3Adapter) && @adapter.kind_of?(DataMapper::Adapters::Sqlite3Adapter)
+              pending 'delegate regexp matches to same system that the InMemory and YAML adapters use'
+            end
+          end
+
+          it 'should be able to search for objects that match value' do
+            Heffalump.all(:color => /ed/).should be_include(@red)
+          end
+
+          it 'should not be able to search for objects that do not match the value' do
+            Heffalump.all(:color => /blak/).should_not be_include(@red)
+          end
+
+          it 'should be able to do a negated search for objects that match value' do
+            Heffalump.all(:color.not => /blak/).should be_include(@red)
+          end
+
+          it 'should not be able to do a negated search for objects that do not match value' do
+            Heffalump.all(:color.not => /ed/).should_not be_include(@red)
+          end
+
+        end
+
+        describe 'gt' do
+          it 'should be able to search for objects with value greater than' do
+            Heffalump.all(:num_spots.gt => 1).should be_include(@two)
+          end
+
+          it 'should not find objects with a value less than' do
+            Heffalump.all(:num_spots.gt => 3).should_not be_include(@two)
+          end
+        end
+
+        describe 'gte' do
+          it 'should be able to search for objects with value greater than' do
+            Heffalump.all(:num_spots.gte => 1).should be_include(@two)
+          end
+
+          it 'should be able to search for objects with values equal to' do
+            Heffalump.all(:num_spots.gte => 2).should be_include(@two)
+          end
+
+          it 'should not find objects with a value less than' do
+            Heffalump.all(:num_spots.gte => 3).should_not be_include(@two)
+          end
+        end
+
+        describe 'lt' do
+          it 'should be able to search for objects with value less than' do
+            Heffalump.all(:num_spots.lt => 3).should be_include(@two)
+          end
+
+          it 'should not find objects with a value less than' do
+            Heffalump.all(:num_spots.gt => 2).should_not be_include(@two)
+          end
+        end
+
+        describe 'lte' do
+          it 'should be able to search for objects with value less than' do
+            Heffalump.all(:num_spots.lte => 3).should be_include(@two)
+          end
+
+          it 'should be able to search for objects with values equal to' do
+            Heffalump.all(:num_spots.lte => 2).should be_include(@two)
+          end
+
+          it 'should not find objects with a value less than' do
+            Heffalump.all(:num_spots.lte => 1).should_not be_include(@two)
+          end
+        end
+      end
+
+      describe 'limits' do
+        it 'should be able to limit the objects' do
+          Heffalump.all(:limit => 2).length.should == 2
+        end
+      end
+    end
+  else
+    it 'needs to support #read and #create to test query matching'
+  end
+end

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

@@ -0,0 +1,106 @@
+share_examples_for 'A DataObjects Adapter' do
+  before :all do
+    raise '+@adapter+ should be defined in before block' unless instance_variable_get('@adapter')
+
+    @log = StringIO.new
+
+    @original_logger = DataMapper.logger
+    DataMapper.logger = DataMapper::Logger.new(@log, :debug)
+
+    # set up the adapter after switching the logger so queries can be captured
+    @adapter = DataMapper.setup(@adapter.name, @adapter.options)
+  end
+
+  after :all do
+    DataMapper.logger = @original_logger
+  end
+
+  def reset_log
+    @log.truncate(0)
+    @log.rewind
+  end
+
+  def log_output
+    @log.rewind
+    @log.read.chomp.gsub(/^\s+~ \(\d+\.?\d*\)\s+/, '')
+  end
+
+  def supports_default_values?
+    @adapter.send(:supports_default_values?)
+  end
+
+  def supports_returning?
+    @adapter.send(:supports_returning?)
+  end
+
+  describe '#create' do
+    describe 'serial properties' do
+      before :all do
+        class ::Article
+          include DataMapper::Resource
+
+          property :id, Serial
+        end
+
+        # create all tables and constraints before each spec
+        if @repository.respond_to?(:auto_migrate!)
+          Article.auto_migrate!
+        end
+
+        reset_log
+
+        Article.create
+      end
+
+      it 'should not send NULL values' do
+        statement = if defined?(DataMapper::Adapters::MysqlAdapter) && @adapter.kind_of?(DataMapper::Adapters::MysqlAdapter)
+          /\AINSERT INTO `articles` \(\) VALUES \(\)\z/
+        elsif supports_default_values? && supports_returning?
+          /\AINSERT INTO "articles" DEFAULT VALUES RETURNING \"id\"\z/
+        elsif supports_default_values?
+          /\AINSERT INTO "articles" DEFAULT VALUES\z/
+        else
+          /\AINSERT INTO "articles" \(\) VALUES \(\)\z/
+        end
+
+        log_output.should =~ statement
+      end
+    end
+
+    describe 'properties without a default' do
+      before :all do
+        class ::Article
+          include DataMapper::Resource
+
+          property :id,    Serial
+          property :title, String
+        end
+
+        # create all tables and constraints before each spec
+        if @repository.respond_to?(:auto_migrate!)
+          Article.auto_migrate!
+        end
+
+        reset_log
+
+        Article.create(:id => 1)
+      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
+        else
+          log_output.should =~ /^INSERT INTO "articles" \("id"\) VALUES \(.{1,2}\)$/i
+        end
+      end
+    end
+  end
+
+  describe '#execute' do
+    it 'should allow queries without return results'
+  end
+
+  describe '#query' do
+    it 'should allow queries with return results'
+  end
+end

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

@@ -0,0 +1,20 @@
+module DataMapper
+  module Chainable
+
+    # TODO: document
+    # @api private
+    def chainable(&block)
+      mod = Module.new(&block)
+      include mod
+      mod
+    end
+
+    # TODO: document
+    # @api private
+    def extendable(&block)
+      mod = Module.new(&block)
+      extend mod
+      mod
+    end
+  end # module Chainable
+end # module DataMapper

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

@@ -0,0 +1,12 @@
+module DataMapper
+  module Deprecate
+    def deprecate(old_method, new_method)
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{old_method}(*args, &block)
+          warn "\#{self.class}##{old_method} is deprecated, use \#{self.class}##{new_method} instead (\#{caller[0]})"
+          send(#{new_method.inspect}, *args, &block)
+        end
+      RUBY
+    end
+  end # module Deprecate
+end # module DataMapper

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

@@ -0,0 +1,23 @@
+module DataMapper
+  module Equalizer
+    def equalize(*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
+
+        def ==(other)
+          return true if equal?(other)
+          #{methods.map { |method| "other.respond_to?(#{method.inspect})" }.join(' && ')} &&
+          #{methods.map { |method| "#{method} == other.#{method}" }.join(' && ')}
+        end
+
+        def hash
+          [ #{methods.join(', ')} ].hash
+        end
+      RUBY
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module DataMapper
+  class << self #:nodoc:
+    attr_accessor :logger
+  end
+
+  class Logger < Extlib::Logger
+    def initialize(*)
+      super
+      self.auto_flush = true
+      DataMapper.logger = self
+    end
+  end # class Logger
+end # module DataMapper

data/lib/dm-core/{naming_conventions.rb → support/naming_conventions.rb}

@@ -20,15 +20,15 @@ module DataMapper
   # DataMapper.setup(name, uri) returns the Adapter for convenience, so you can
   # use code like this:
   #
-  #   adapter = DataMapper.setup(:default, "mock://localhost/mock")
-  #   adapter.resource_naming_convention = DataMapper::NamingConventions::Resource::Underscored
+  #   adapter = DataMapper.setup(:default, 'mock://localhost/mock')
+  #   adapter.resource_naming_convention = NamingConventions::Resource::Underscored
   module NamingConventions
 
     module Resource
 
       module UnderscoredAndPluralized
         def self.call(name)
-          Extlib::Inflection.pluralize(Extlib::Inflection.underscore(name)).gsub('/','_')
+          Extlib::Inflection.pluralize(Extlib::Inflection.underscore(name)).gsub('/', '_')
         end
       end # module UnderscoredAndPluralized
 
@@ -46,7 +46,7 @@ module DataMapper
 
       module Yaml
         def self.call(name)
-          Extlib::Inflection.pluralize(Extlib::Inflection.underscore(name)) + ".yaml"
+          "#{Extlib::Inflection.pluralize(Extlib::Inflection.underscore(name))}.yaml"
         end
       end # module Yaml
 
@@ -56,7 +56,7 @@ module DataMapper
 
       module UnderscoredAndPluralized
         def self.call(property)
-          Extlib::Inflection.pluralize(Extlib::Inflection.underscore(property.name.to_s)).gsub('/','_')
+          Extlib::Inflection.pluralize(Extlib::Inflection.underscore(property.name.to_s)).gsub('/', '_')
         end
       end # module UnderscoredAndPluralized
 
@@ -74,7 +74,7 @@ module DataMapper
 
       module Yaml
         def self.call(property)
-          Extlib::Inflection.pluralize(Extlib::Inflection.underscore(property.name.to_s)) + ".yaml"
+          "#{Extlib::Inflection.pluralize(Extlib::Inflection.underscore(property.name.to_s))}.yaml"
         end
       end # module Yaml