ardm-core 1.2.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5d88a1388e05bc0987ce1ea0fcfd902bd19a91b5
-  data.tar.gz: 185295c3d88d126fcefe257eb50894cb9fccb99f
+  metadata.gz: 8efb580769f20f6f9438dd38548c3a7e4f1cd482
+  data.tar.gz: 38b486935a5a8c73f4f300541940198500df54cd
 SHA512:
-  metadata.gz: e3244f70503a3c2174bb896dda56ab841690761edfa2dd21b0009be74d5bd20bd7f125bb088b37066084d27ccb61677eb376817f97e7e8d560dacd26fbfdf56a
-  data.tar.gz: 65012a3e5de43b6923fb0ac9a5e8333fb77315ebdf1bcb7ee5bab75c68127762ce8c35fbf3fb2f966d5be691cf66e6175d79e88f5287f970d5d0a7a57b85e942
+  metadata.gz: 7f02886cc1a7446399518d8a3999485672a7ee4d061a60fae5921feb7958f01b4a27480b6aa9204c14b24d0c139dfb8becd91a748f5119a7cc6971a67a69bd2b
+  data.tar.gz: 061949f62500d4c206bc1f01a1fc9ad07f406a1363eede06ea72f739524f9d3bcf3335cd28a18cc376281e5fd43416f7225328714e600b91c20e27ffdec488f9

data/.gitignore

@@ -15,10 +15,13 @@ tmtags
 
 ## Rubinius
 *.rbc
+.rbx
 
 ## PROJECT::GENERAL
 *.gem
 coverage
+profiling
+turbulence
 rdoc
 pkg
 tmp

data/.travis.yml

@@ -9,8 +9,8 @@ before_install:
 script: "bundle exec rake spec"
 env:
   - "ADAPTER=in_memory"
-  - "ADAPTER=yaml"
-  - "ADAPTER=sqlite"
+#  - "ADAPTER=yaml"
+#  - "ADAPTER=sqlite"
   - "ADAPTER=mysql DM_DB_USER=root DM_DB_PASSWORD=''"
 rvm:
   - 1.9.3

data/Gemfile

@@ -9,21 +9,11 @@ gemspec
 SOURCE         = ENV.fetch('SOURCE', :git).to_sym
 REPO_POSTFIX   = SOURCE == :path ? ''                                : '.git'
 DATAMAPPER     = SOURCE == :path ? Pathname(__FILE__).dirname.parent : 'http://github.com/ar-dm'
-DM_VERSION     = '~> 1.2.0'
+DM_VERSION     = '~> 1.2'
 DO_VERSION     = '~> 0.10.6'
 DM_DO_ADAPTERS = %w[ sqlite postgres mysql oracle sqlserver ]
 CURRENT_BRANCH = ENV.fetch('GIT_BRANCH', 'master')
 
-platforms :mri_18 do
-  group :quality do
-
-    gem 'rcov',      '~> 0.9.10'
-    gem 'yard',      '~> 0.7.2'
-    gem 'yardstick', '~> 0.4'
-
-  end
-end
-
 group :datamapper do
 
   adapters = ENV['ADAPTERS'] || ENV['ADAPTER']

data/ardm-core.gemspec

@@ -18,8 +18,8 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- spec/*`.split("\n")
   s.extra_rdoc_files = %w[LICENSE README.rdoc]
 
-  s.add_dependency('addressable', "~> 2.3")
+  s.add_dependency 'addressable', '~> 2.3', '>= 2.3.5'
 
-  s.add_development_dependency('rake',  '~> 0.9')
-  s.add_development_dependency('rspec', '~> 1.3')
+  s.add_development_dependency 'rake',  '~> 10.0'
+  s.add_development_dependency 'rspec', '~> 1.3'
 end

data/lib/dm-core.rb

@@ -120,7 +120,7 @@ end
 # == Setup and Configuration
 # DataMapper uses URIs or a connection hash to connect to your data-store.
 # URI connections takes the form of:
-#   DataMapper.setup(:default, 'protocol://username:password@localhost:port/path/to/repo')
+#   DataMapper.setup(:default, 'protocol://username:password@127.0.0.1:port/path/to/repo')
 #
 # Breaking this down, the first argument is the name you wish to give this
 # connection.  If you do not specify one, it will be assigned :default. If you
@@ -137,7 +137,7 @@ end
 #
 # Here's some examples
 #   DataMapper.setup(:default, 'sqlite3://path/to/your/project/db/development.db')
-#   DataMapper.setup(:default, 'mysql://localhost/dm_core_test')
+#   DataMapper.setup(:default, 'mysql://127.0.0.1/dm_core_test')
 #     # no auth-info
 #   DataMapper.setup(:default, 'postgres://root:supahsekret@127.0.0.1/dm_core_test')
 #     # with auth-info

data/lib/dm-core/adapters/abstract_adapter.rb

@@ -35,7 +35,7 @@ module DataMapper
       #
       # Note that when you use
       #
-      # DataMapper.setup(:default, 'postgres://postgres@localhost/dm_core_test')
+      # DataMapper.setup(:default, 'postgres://postgres@127.0.0.1/dm_core_test')
       #
       # the adapter name is currently set to :default
       #

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

@@ -207,6 +207,7 @@ module DataMapper
           @required      = options.fetch(:required, true)
           @key           = options.fetch(:key,      false)
           @unique        = options.fetch(:unique,   false)
+          @unique_index  = options.fetch(:unique_index, @unique)
           target_model ||= DataMapper::Inflector.camelize(name)
           options        = { :min => @required ? 1 : 0, :max => 1 }.update(options)
           super
@@ -260,10 +261,11 @@ module DataMapper
         # @api private
         def source_key_options(target_property)
           options = DataMapper::Ext::Hash.only(target_property.options, :length, :precision, :scale).update(
-            :index    => name,
-            :required => required?,
-            :key      => key?,
-            :unique   => @unique
+            :index        => name,
+            :required     => required?,
+            :key          => key?,
+            :unique       => @unique,
+            :unique_index => @unique_index
           )
 
           if target_property.primitive == Integer

data/lib/dm-core/collection.rb

@@ -501,6 +501,7 @@ module DataMapper
     #
     # @api public
     def each
+      return to_enum unless block_given?
       super do |resource|
         begin
           original, resource.collection = resource.collection, self

data/lib/dm-core/model.rb

@@ -314,6 +314,7 @@ module DataMapper
     end
 
     def each(&block)
+      return to_enum unless block_given?
       all.each(&block)
       self
     end
@@ -847,7 +848,7 @@ module DataMapper
       repository_name = self.repository_name
       if properties(repository_name).empty? &&
         !relationships(repository_name).any? { |relationship| relationship.kind_of?(Associations::ManyToOne::Relationship) }
-        raise IncompleteModelError, "#{name} must have at least one property or many to one relationship to be valid"
+        raise IncompleteModelError, "#{name} must have at least one property or many to one relationship in #{repository_name} to be valid"
       end
     end
 
@@ -861,7 +862,7 @@ module DataMapper
     # @api private
     def assert_valid_key
       if key(repository_name).empty?
-        raise IncompleteModelError, "#{name} must have a key to be valid"
+        raise IncompleteModelError, "#{name} must have a key in #{repository_name} to be valid"
       end
     end
 

data/lib/dm-core/model/property.rb

@@ -175,7 +175,7 @@ module DataMapper
 
       # @api private
       def key_conditions(repository, key)
-        Hash[ self.key(repository.name).zip(key.nil? ? [] : key) ]
+        Hash[self.key(repository.name).zip(Array(key))]
       end
 
     private
@@ -234,6 +234,7 @@ module DataMapper
           #{writer_visibility}
           def #{writer_name}(value)
             property = properties[#{name.inspect}]
+            value    = property.typecast(value)
             self.persistence_state = persistence_state.set(property, value)
             persistence_state.get(property)
           end

data/lib/dm-core/property.rb

@@ -622,7 +622,7 @@ module DataMapper
     #
     # @api private
     def set(resource, value)
-      set!(resource, typecast(value))
+      set!(resource, value)
     end
 
     # Set the ivar value in the resource
@@ -682,8 +682,10 @@ module DataMapper
     def typecast(value)
       if value.nil? || primitive?(value)
         value
-      elsif respond_to?(:typecast_to_primitive)
+      elsif respond_to?(:typecast_to_primitive, true)
         typecast_to_primitive(value)
+      else
+        value
       end
     end
 

data/lib/dm-core/query.rb

@@ -1017,7 +1017,7 @@ module DataMapper
             add_condition(condition)
 
           when Hash
-            condition.each { |kv| append_condition(*kv) }
+            condition.each { |key, value| append_condition(key, value) }
 
           when Array
             statement, *bind_values = *condition

data/lib/dm-core/resource.rb

@@ -280,7 +280,10 @@ module DataMapper
     # @api public
     def attribute_set(name, value)
       property = properties[name]
-      self.persistence_state = persistence_state.set(property, value) if property
+      if property
+        value = property.typecast(value)
+        self.persistence_state = persistence_state.set(property, value)
+      end
     end
 
     alias_method :[]=, :attribute_set
@@ -335,6 +338,10 @@ module DataMapper
               raise ArgumentError, "The attribute '#{name}' is not accessible in #{model}"
             end
           when Associations::Relationship, Property
+            # only call a public #typecast (e.g. on Property instances)
+            if name.respond_to?(:typecast)
+              value = name.typecast(value)
+            end
             self.persistence_state = persistence_state.set(name, value)
         end
       end

data/lib/dm-core/resource/persistence_state/transient.rb

@@ -50,7 +50,20 @@ module DataMapper
 
         def set_default_value(subject)
           return if subject.loaded?(resource) || !subject.default?
-          set(subject, subject.default_for(resource))
+          default = typecast_default(subject, subject.default_for(resource))
+          set(subject, default)
+        end
+
+        def typecast_default(subject, default)
+          return default unless subject.respond_to?(:typecast)
+
+          typecasted_default = subject.send(:typecast, default)
+          unless typecasted_default.eql?(default)
+            warn "Automatic typecasting of default property values is deprecated " +
+                 "(#{default.inspect} was casted to #{typecasted_default.inspect}). " +
+                 "Specify the correct type for #{resource.class}."
+          end
+          typecasted_default
         end
 
         def track(subject)

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

@@ -18,6 +18,8 @@ module DataMapper
 
         def describe_adapter(kind, &block)
           describe("with #{kind} adapter") do
+            let(:adapter)    { @adapter    }
+            let(:repository) { @repository }
 
             before :all do
               # store these in instance vars for the shared adapter specs

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

@@ -45,12 +45,11 @@ module DataMapper
         next if object.kind_of?(DataMapper::Logger)                    ||
                 object.kind_of?(DataMapper::DescendantSet)             ||
                 object.kind_of?(DataMapper::Adapters::AbstractAdapter) ||
-                object.class.name[0, 13] == 'DataObjects::'
+                object.class.name.to_s[0, 13] == 'DataObjects::'
 
         # skip classes and modules in the DataMapper namespace
         next if object.kind_of?(Module) &&
-                !object.name.nil?       &&
-                object.name[0, 12] == 'DataMapper::'
+                object.name.to_s[0, 12] == 'DataMapper::'
 
         # skip when the ivar is no longer defined in the object
         next unless object.instance_variable_defined?(ivar)

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

@@ -115,7 +115,9 @@ module DataMapper
         end
 
         def connection_uri
-          "#{adapter_name}://#{username}:#{password}@#{host}/#{storage_name}"
+          "#{adapter_name}://#{username}%s@#{host}/#{storage_name}".tap do |s|
+            return s % ((password.empty?) ? "" : ":#{password}")
+          end
         end
 
         def storage_name
@@ -139,7 +141,7 @@ module DataMapper
         end
 
         def host
-          ENV.fetch('DM_DB_HOST', 'localhost')
+          ENV.fetch('DM_DB_HOST', '127.0.0.1')
         end
 
         # Test the connection

data/lib/dm-core/spec/shared/adapter_spec.rb

@@ -22,38 +22,58 @@ share_examples_for 'An Adapter' do
     end
   end
 
-  before :all do
-    raise '+@adapter+ should be defined in before block' unless instance_variable_get('@adapter')
+  # Hack to detect cases a let(:heffalump_model) is not present
+  unless instance_methods.map(&:to_s).include?('heffalump_model')
+    # This is the default Heffalump model. You can replace it with your own
+    # (using let/let!) # but # be shure the replacement provides the required
+    # properties.
+    let(:heffalump_model) do
+      model = Class.new do
+        include DataMapper::Resource
+
+        property :id,        DataMapper::Property::Serial
+        property :color,     DataMapper::Property::String
+        property :num_spots, DataMapper::Property::Integer
+        property :striped,   DataMapper::Property::Boolean
+
+        # This is needed for DataMapper.finalize
+        def self.name; 'Heffalump'; end
+      end
 
-    class ::Heffalump
-      include DataMapper::Resource
+      DataMapper.finalize
 
-      property :id,        Serial
-      property :color,     String
-      property :num_spots, Integer
-      property :striped,   Boolean
+      model
     end
+  end
+
+  before :all do
+    raise '+#adapter+ should be defined in a let(:adapter) block' unless respond_to?(:adapter)
+    raise '+#repository+ should be defined in a let(:repository) block' unless respond_to?(:repository)
 
     DataMapper.finalize
 
     # create all tables and constraints before each spec
-    if @repository.respond_to?(:auto_migrate!)
-      Heffalump.auto_migrate!
+    if repository.respond_to?(:auto_migrate!)
+      heffalump_model.auto_migrate!
     end
   end
 
   if adapter_supports?(:create)
     describe '#create' do
+      after do
+        heffalump_model.destroy
+      end
+
       it 'should not raise any errors' do
         lambda {
-          Heffalump.create(:color => 'peach')
+          heffalump_model.new(:color => 'peach').save.should be(true)
         }.should_not raise_error
       end
 
       it 'should set the identity field for the resource' do
-        heffalump = Heffalump.new(:color => 'peach')
+        heffalump = heffalump_model.new(:color => 'peach')
         heffalump.id.should be_nil
-        heffalump.save
+        heffalump.save.should be(true)
         heffalump.id.should_not be_nil
       end
     end
@@ -64,19 +84,23 @@ share_examples_for 'An Adapter' do
   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
+        @heffalump = heffalump_model.create(:color => 'brownish hue')
+        @heffalump.should be_saved
+        @query = heffalump_model.all.query
+      end
+
+      after :all do
+        heffalump_model.destroy
       end
 
       it 'should not raise any errors' do
         lambda {
-          Heffalump.all()
+          heffalump_model.all()
         }.should_not raise_error
       end
 
-      it 'should return stuff' do
-        Heffalump.all.should be_include(@heffalump)
+      it 'should return expected results' do
+        heffalump_model.all.should == [ @heffalump ]
       end
     end
   else
@@ -86,34 +110,39 @@ share_examples_for 'An Adapter' do
   if adapter_supports?(:update)
     describe '#update' do
       before do
-        @heffalump = Heffalump.create(:color => 'indigo')
+        @heffalump = heffalump_model.create(:color => 'peach', :num_spots => 1, :striped => false)
+        @heffalump.should be_saved
+      end
+
+      after do
+        heffalump_model.destroy
       end
 
       it 'should not raise any errors' do
         lambda {
-          @heffalump.color = 'violet'
-          @heffalump.save
+          @heffalump.num_spots = 0
+          @heffalump.save.should be(true)
         }.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
+        key = @heffalump.key
+        @heffalump.num_spots = 0
+        @heffalump.save.should be(true)
+        @heffalump.key.should == key
       end
 
       it 'should update altered fields' do
-        @heffalump.color = 'violet'
-        @heffalump.save
-        Heffalump.get(*@heffalump.key).color.should == 'violet'
+        @heffalump.num_spots = 0
+        @heffalump.save.should be(true)
+        heffalump_model.get!(*@heffalump.key).num_spots.should be(0)
       end
 
       it 'should not alter other fields' do
-        color = @heffalump.color
-        @heffalump.num_spots = 3
-        @heffalump.save
-        Heffalump.get(*@heffalump.key).color.should == color
+        num_spots = @heffalump.num_spots
+        @heffalump.striped = true
+        @heffalump.save.should be(true)
+        heffalump_model.get!(*@heffalump.key).num_spots.should be(num_spots)
       end
     end
   else
@@ -123,7 +152,12 @@ share_examples_for 'An Adapter' do
   if adapter_supports?(:delete)
     describe '#delete' do
       before do
-        @heffalump = Heffalump.create(:color => 'forest green')
+        @heffalump = heffalump_model.create(:color => 'forest green')
+        @heffalump.should be_saved
+      end
+
+      after do
+        heffalump_model.destroy
       end
 
       it 'should not raise any errors' do
@@ -133,9 +167,9 @@ share_examples_for 'An Adapter' do
       end
 
       it 'should delete the requested resource' do
-        id = @heffalump.id
+        key = @heffalump.key
         @heffalump.destroy
-        Heffalump.get(id).should be_nil
+        heffalump_model.get(*key).should be_nil
       end
     end
   else
@@ -145,178 +179,183 @@ share_examples_for 'An Adapter' do
   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)
+        @red  = heffalump_model.create(:color => 'red')
+        @two  = heffalump_model.create(:num_spots => 2)
+        @five = heffalump_model.create(:num_spots => 5)
+        [ @red, @two, @five ].each { |resource| resource.should be_saved }
+      end
+
+      after :all do
+        heffalump_model.destroy
       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)
+            heffalump_model.all(:num_spots => 1..5).should 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)
+            heffalump_model.all(:num_spots => 1...6).should 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)
+            heffalump_model.all(:num_spots => 1..4).should_not 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)
+            heffalump_model.all(:num_spots => 1...5).should_not 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)
+            heffalump_model.all(:color.not => 'red').should_not include(@red)
           end
 
           it 'should include objects that are not like the value' do
-            Heffalump.all(:color.not => 'black').should be_include(@red)
+            heffalump_model.all(:color.not => 'black').should 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)
+            heffalump_model.all(:color.not => nil).should include(@red)
           end
 
           it 'should not include objects with a nil value' do
-            Heffalump.all(:color.not => nil).should_not be_include(@two)
+            heffalump_model.all(:color.not => nil).should_not 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 ]
+            heffalump_model.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 ]
+            heffalump_model.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(
+            heffalump_model.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])
+                DataMapper::Query::Conditions::Comparison.new(:in, heffalump_model.properties[:color], []),
+                DataMapper::Query::Conditions::Comparison.new(:in, heffalump_model.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)
+            heffalump_model.all(:num_spots.not => [ 1, 3, 5, 7 ]).should 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)
+            heffalump_model.all(:num_spots.not => [ 1, 3, 5, 7 ]).should_not 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)
+            heffalump_model.all(:num_spots.not => 1..4).should 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)
+            heffalump_model.all(:num_spots.not => 1...5).should 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)
+            heffalump_model.all(:num_spots.not => 1..5).should_not 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)
+            heffalump_model.all(:num_spots.not => 1...6).should_not 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)
+            heffalump_model.all(:color.like => '%ed').should 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)
+            heffalump_model.all(:color.like => '%blak%').should_not include(@red)
           end
         end
 
         describe 'regexp' do
           before do
-            if (defined?(DataMapper::Adapters::SqliteAdapter) && @adapter.kind_of?(DataMapper::Adapters::SqliteAdapter) ||
-                defined?(DataMapper::Adapters::SqlserverAdapter) && @adapter.kind_of?(DataMapper::Adapters::SqlserverAdapter))
+            if (defined?(DataMapper::Adapters::SqliteAdapter) && adapter.kind_of?(DataMapper::Adapters::SqliteAdapter) ||
+                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
 
           it 'should be able to search for objects that match value' do
-            Heffalump.all(:color => /ed/).should be_include(@red)
+            heffalump_model.all(:color => /ed/).should 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)
+            heffalump_model.all(:color => /blak/).should_not 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)
+            heffalump_model.all(:color.not => /blak/).should 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)
+            heffalump_model.all(:color.not => /ed/).should_not 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)
+            heffalump_model.all(:num_spots.gt => 1).should 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)
+            heffalump_model.all(:num_spots.gt => 3).should_not 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)
+            heffalump_model.all(:num_spots.gte => 1).should 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)
+            heffalump_model.all(:num_spots.gte => 2).should 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)
+            heffalump_model.all(:num_spots.gte => 3).should_not 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)
+            heffalump_model.all(:num_spots.lt => 3).should 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)
+            heffalump_model.all(:num_spots.gt => 2).should_not 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)
+            heffalump_model.all(:num_spots.lte => 3).should 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)
+            heffalump_model.all(:num_spots.lte => 2).should 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)
+            heffalump_model.all(:num_spots.lte => 1).should_not include(@two)
           end
         end
       end
 
       describe 'limits' do
         it 'should be able to limit the objects' do
-          Heffalump.all(:limit => 2).length.should == 2
+          heffalump_model.all(:limit => 2).length.should == 2
         end
       end
     end